.png)
ADP Integration Guide
Integrate ADP workforce, payroll, time, and organizational data with enterprise systems through product-specific REST APIs, selected event notifications, and controlled workflows.
ADP integration options at a glance
ADP provides product-specific REST APIs across workforce, payroll, time, talent, and related human-capital-management capabilities. Selected ADP products and business events can provide webhook-style or other event notifications, while bulk, batch, asynchronous, and file-based exchange capabilities vary by product and entitlement. ADP integrations generally use OAuth 2.0 with application credentials, scopes, consent, and tenant authorization. Martini can consume ADP APIs, follow pagination, orchestrate scheduled or event-driven workflows, transform JSON and other supported payloads, expose endpoints for notifications, and route validated results to downstream systems. Each implementation should confirm the customer's ADP product, region, API version, operations, and entitlements.
| Integration point | Supported by ADP? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | ADP provides product-specific REST APIs for workforce, payroll, time, talent, and related human-capital-management data. Availability and operations depend on product, entitlement, and approval. | Martini can consume ADP REST endpoints from workflows, handle JSON responses and pagination, apply business rules, and map results to internal or downstream models. |
| Webhooks and outbound callbacks | Limited | Selected ADP products and business events provide event-notification capabilities; coverage is not universal across ADP objects or lifecycle changes. | Martini can expose an API endpoint or workflow trigger, validate supported notifications, retrieve the current object when necessary, and route the result. |
| Bulk, asynchronous, and batch APIs | Limited | Collection, payroll-batch, or asynchronous processing varies by ADP API product and may include product-specific limits, status operations, and item-level errors. | Martini can orchestrate batch submissions, poll processing status where documented, split or aggregate payloads, and handle partial success without replaying successful items. |
| File and attachment exchange | Limited | File exchange and document capabilities may be available for particular ADP products, but no universal file or attachment API applies across the portfolio. | Where documented by the selected ADP product, Martini can validate and transform CSV, JSON, XML, or spreadsheet files and route processing outcomes. |
| Authentication | Yes | ADP integrations generally use OAuth 2.0 with application credentials, scopes, customer consent, tenant authorization, and product-specific permissions. | Martini can apply API authentication through protected environment configuration, manage credentials as secrets, and support token expiration and reauthentication handling. |
| Incremental synchronization | Limited | Selected APIs may provide timestamps, effective dates, paging, or other filtering mechanisms, but ADP does not expose one universal change-tracking contract. | Martini can persist checkpoints and use the documented filters for the selected endpoint rather than assuming a universal updated-since parameter. |
| GraphQL APIs | Not confirmed | No current general-purpose ADP GraphQL API was confirmed in the supplied research. | Martini can consume GraphQL generally, but this page does not assume GraphQL availability for ADP. |
| SOAP APIs | Not confirmed | No current general-purpose ADP SOAP surface was confirmed as the recommended approach for new integrations. | Martini supports SOAP generally, but ADP integrations should use documented REST or exchange mechanisms unless product-specific SOAP documentation confirms otherwise. |
| Database access | No | ADP does not expose a customer database for direct JDBC access in the supplied research. | Martini should use documented ADP APIs or exchange mechanisms rather than attempting direct database connectivity. |
How ADP exposes data and business events
ADP REST APIs
ADP exposes product-specific REST APIs for workforce, payroll, time, talent, and related human-capital-management capabilities. The available resources, operations, schemas, and permissions depend on the customer's ADP product, region, tenant, and entitlements.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with OAuth 2.0, calls the selected ADP endpoint, follows the documented pagination or filtering model, transforms the response, applies validation and business rules, and writes the result to a target system or exposes a normalized Martini API.
Implementation sequence
ADP event notifications
ADP supports event-notification capabilities for selected products and business events. Delivery may use a webhook, callback, or another notification service, and the event may contain a complete object or only an identifier and change summary.
Martini implementation pattern
Martini implementation pattern: expose a controlled API endpoint or workflow start trigger, validate delivery and event identity, retrieve the current ADP object when the notification is incomplete, and process the change idempotently.
Implementation sequence
ADP batch and asynchronous processing
ADP offers collection, payroll-batch, or asynchronous processing capabilities in some product areas, but there is no universal bulk contract across the portfolio. Limits, job status behavior, and item-level error reporting must be confirmed for the selected API.
Martini implementation pattern
Martini implementation pattern: assemble bounded batches, submit them through the documented ADP operation, poll or receive processing status where supported, and persist individual outcomes for reconciliation.
Implementation sequence
ADP file exchange
Some ADP products may support file-based or document-related exchange. Because file and attachment capabilities are product-specific, the selected ADP documentation must confirm format, transport, size, and processing behavior.
Martini implementation pattern
Martini implementation pattern: receive or retrieve the applicable file, validate its structure and security requirements, transform the contents, invoke the supported ADP exchange operation, and record processing results.
Implementation sequence
Common ADP integration patterns
Pattern 1: Synchronize ADP workers to an identity platform
When to use this pattern
Use this pattern when ADP is the authoritative source for worker status, employment dates, organization, manager, or position information used by identity lifecycle processes. The trigger may be a schedule or a supported ADP worker event.
Integration direction
Example Mapping
| ADP Field | Canonical Field | Target Field |
|---|---|---|
| worker.workerID.idValue | workerId | externalId |
| worker.person.legalName.givenName | givenName | givenName |
| worker.person.legalName.familyName1 | familyName | surname |
| worker.workerStatus.statusCode.codeValue | employmentStatus | accountEnabled |
Martini implementation pattern
A Martini workflow retrieves or receives eligible Workers, normalizes nested data, filters sensitive fields, applies joiner-mover-leaver rules, and performs idempotent target updates. It records event or synchronization checkpoints and retries transient failures without replaying completed updates.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- scheduled and event-driven triggers
- error handling
Pattern 2: Send ADP worker and organization data to Salesforce
When to use this pattern
Use this pattern when Salesforce needs current employee, organization, position, or account-owner context for sales, service, or employee-related processes. The integration should transfer only permitted fields and define source-of-truth rules.
Integration direction
Example Mapping
| ADP Field | Canonical Field | Target Field |
|---|---|---|
| worker.workerID.idValue | workerId | ADP_Worker_ID__c |
| organization.organizationName | organizationName | Department__c |
| position.positionTitle | positionTitle | Title |
| worker.workerStatus.effectiveDate | statusEffectiveDate | Status_Effective_Date__c |
Martini implementation pattern
Martini consumes ADP REST data on a schedule or after selected notifications, maps Organizations, Positions, and Workers to Salesforce objects or custom objects, validates references, and uses upserts keyed by stable identifiers. Rejected records are isolated for review and reconciliation.
Martini capabilities used
- workflows
- REST API consumption
- data mapping
- validation
- idempotent upserts
- monitoring and error handling
Pattern 3: Orchestrate payroll inputs into ADP
When to use this pattern
Use this pattern when an upstream HR or finance application must submit approved payroll inputs to an ADP payroll product. It is appropriate only when the customer's ADP API exposes the required write operation and permissions.
Integration direction
Example Mapping
| ADP Field | Canonical Field | Target Field |
|---|---|---|
| employee.externalId | workerId | workerID |
| payCode | payCode | earningCode |
| effectiveDate | payPeriodDate | payDate |
| amount | inputAmount | amount |
Martini implementation pattern
A Martini API or workflow receives approved inputs, validates worker identifiers, pay codes, dates, and amounts, transforms the request to the selected ADP payroll schema, and submits it with OAuth authorization. The workflow captures response identifiers and separates validation, authorization, transient, and item-level business errors.
Martini capabilities used
- API exposure
- workflow orchestration
- data transformation
- validation
- business rules
- error handling and controlled retry
Pattern 4: Synchronize ADP time-off requests to a workforce application
When to use this pattern
Use this pattern when approved ADP absences must update scheduling, project-capacity, or service-availability information. Use supported event notifications when available; otherwise use documented filters, effective dates, or timestamps in a scheduled workflow.
Integration direction
Example Mapping
| ADP Field | Canonical Field | Target Field |
|---|---|---|
| timeOffRequest.requestID | timeOffId | externalReference |
| timeOffRequest.workerID | workerId | assignee |
| timeOffRequest.startDate | absenceStart | startDate |
| timeOffRequest.status | approvalStatus | workflowStatus |
Martini implementation pattern
Martini retrieves or receives Time Off Requests, maps statuses and effective dates, applies approval and date rules, and creates or updates downstream availability information. An idempotency key prevents duplicate absences, while failed items remain traceable for replay or reconciliation.
Martini capabilities used
- scheduled workflows
- event processing
- mapping and transformation
- business rules
- idempotency
- error handling
Applications commonly integrated with ADP
Organizations can connect ADP with adjacent identity, service, finance, HR, and operational applications. The exact direction and data scope depend on the ADP product, customer entitlements, and the target application's implementation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize worker, organization, or account-owner information for sales operations, service processes, and employee-related workflows. | ADP → Martini → Salesforce | A scheduled or event-triggered Martini workflow retrieves Workers and Organizations, applies field-level filtering and normalization, then performs idempotent upserts to Salesforce while recording rejected items for review. |
| ServiceNow | Support employee-related records, joiner-mover-leaver processes, and service workflows using authoritative ADP worker and organization data. | ADP → Martini → ServiceNow | Martini consumes ADP worker changes or polls selected endpoints, maps employment status and organizational attributes to ServiceNow fields, and routes failures through retry and exception handling. |
| Microsoft Entra ID | Drive identity lifecycle, department updates, employment-status changes, and access-governance decisions from HR data. | ADP → Martini → Microsoft Entra ID | Martini retrieves or receives eligible Worker changes, applies joiner-mover-leaver rules, and calls the target identity APIs using idempotent provisioning and duplicate protection. |
| Okta | Automate user lifecycle and group or application-access decisions based on worker status and organizational attributes. | ADP → Martini → Okta | A Martini workflow normalizes ADP Workers and Positions, evaluates access rules, and submits controlled updates to Okta with checkpointing and retry handling. |
| NetSuite | Exchange employee, organizational, payroll, or finance-related data between ADP processes and financial operations. | ADP → Martini → NetSuite | Martini maps ADP payroll or organization payloads to NetSuite structures, validates effective dates and identifiers, and supports bidirectional orchestration where both APIs authorize the required operations. |
| Workday | Exchange worker or organizational data where ADP and Workday coexist for different HR, payroll, or planning responsibilities. | ADP → Martini → Workday | Martini establishes source-of-truth rules by data domain, transforms effective-dated Workers and Organizations, and synchronizes only approved fields with reconciliation and error queues. |
| Microsoft Dynamics 365 | Synchronize employee, organization, finance, or operational data for organizations using Dynamics 365 alongside ADP. | ADP → Martini → Microsoft Dynamics 365 | A scheduled Martini workflow retrieves eligible ADP data, applies product-specific mappings and business rules, and writes validated changes to the appropriate Dynamics 365 API. |
| Jira | Reflect employee or organizational information in project, service, or access-related workflows. | ADP → Martini → Jira | Martini transforms selected ADP Worker or Organization attributes into Jira users, project metadata, or workflow inputs where the target model and permissions support the use case. |
How to build a ADP integration in Martini
Objective
Identify the exact ADP product, API, tenant, region, and required operations before configuring access.
Instructions in Martini
- Register or authorize the integration through the applicable ADP developer or marketplace process.
- Configure OAuth 2.0 client credentials, scopes, consent, and environment-specific settings.
- Store client secrets and tokens in protected Martini configuration.
- Confirm test and production access separately where available.
Objective
Select the trigger that matches the ADP capability and synchronization requirement.
Instructions in Martini
- Use a supported ADP event notification for selected business changes.
- Use a scheduler when event coverage is unavailable or reconciliation is required.
- Use a Martini API when an upstream application submits approved data such as payroll inputs.
Objective
Acquire complete ADP data while respecting product-specific schemas, pagination, and notification behavior.
Instructions in Martini
- Receive and validate supported ADP notifications at a controlled Martini endpoint.
- Retrieve the current ADP object when an event contains only an identifier or summary.
- Follow documented page, cursor, timestamp, effective-date, or collection semantics.
Objective
Coordinate calls, transformations, target writes, checkpoints, and exceptions in a maintainable Martini workflow.
Instructions in Martini
- Separate transport, validation, mapping, business rules, and target operations.
- Persist synchronization checkpoints and event identifiers where required.
- Use bounded concurrency and sequencing appropriate to ADP limits and payroll periods.
Objective
Convert ADP's product-specific nested structures into a canonical or target-specific model.
Instructions in Martini
- Map Workers, Organizations, Positions, Pay Statements, Time Off Requests, or Payroll Inputs explicitly.
- Normalize dates, statuses, identifiers, and effective-dated values.
- Minimize personal and payroll data transferred to downstream systems.
Objective
Ensure only authorized, valid, and operationally appropriate data is transmitted.
Instructions in Martini
- Validate worker identifiers, pay codes, amounts, dates, and required relationships.
- Apply source-of-truth, privacy, employment-status, and approval rules.
- Reject or quarantine invalid items without discarding successful items in the same batch.
Common ADP data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Workers | Synchronize employee and worker profile, employment, organizational, and work-assignment information. | Microsoft Entra ID, Okta, Salesforce, ServiceNow, Workday | Martini retrieves or receives eligible changes, normalizes nested fields, filters sensitive data, applies effective-date rules, and performs idempotent upserts. |
| Organizations | Represent departments, companies, organizational units, and related structures. | Salesforce, ServiceNow, NetSuite, Workday, Microsoft Dynamics 365 | Martini maps organization identifiers and hierarchies to target structures, validates relationships, and maintains checkpoints for incremental synchronization. |
| Positions | Represent jobs, positions, assignments, and related employment information. | Salesforce, Okta, Workday, Microsoft Entra ID | Martini transforms position and assignment attributes, applies access or ownership rules, and routes invalid references to exception handling. |
| Pay Statements | Exchange worker pay statement and payroll-result information where the selected ADP product permits access. | NetSuite, finance applications, employee-facing applications | Martini limits fields to the approved purpose, transforms payroll structures, protects sensitive values in logs, and handles authorization and validation failures. |
| Time Off Requests | Synchronize time-off requests, statuses, and approved absences. | Workforce scheduling applications, project applications, ServiceNow | Martini retrieves or processes supported changes, maps status and effective dates, and prevents duplicate absence creation through idempotent keys. |
| Payroll Inputs | Submit payroll-related input data for processing where the customer's ADP payroll product exposes the required write operation. | ADP payroll products, HR or finance applications | Martini validates worker identifiers, pay codes, dates, and amounts, submits authorized payloads, and separates item-level failures from successful items. |
Authentication and security considerations
OAuth 2.0 and product authorization
ADP integrations generally use OAuth 2.0 access tokens, application credentials, scopes, customer consent, and tenant or product authorization. Requirements vary by ADP API family and entitlement.
Protected configuration
Store ADP client credentials, tokens, endpoints, and environment-specific settings in protected Martini configuration rather than workflow mappings or source code.
Data minimization
- Transfer only worker, payroll, time, and organizational fields required for the business process.
- Protect personal and payroll data in transit, at rest, and in operational logs.
- Separate test and production credentials and data where applicable.
Operational considerations for ADP integrations
Product variation
ADP is a portfolio of products rather than one uniform API. Confirm the product, region, tenant, API version, operations, permissions, and entitlement before implementation.
Volume and throttling
Follow documented pagination and collection limits, use bounded concurrency, respect Retry-After when supplied, and schedule high-volume synchronization appropriately.
Effective-dated data
Distinguish current and future changes, employment status dates, payroll periods, position history, and retroactive corrections.
Idempotency and reconciliation
Use event identifiers or stable object keys, durable checkpoints, idempotent upserts, and reconciliation workflows for missed notifications or partial failures.
Schema and testing
Manage API versions explicitly, validate required fields, tolerate appropriate additive changes, and test representative Worker, Payroll, Organization, Position, and Time Off Request payloads.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini coordinates ADP API calls, event handling, scheduled synchronization, target writes, validation, and exception paths in reusable workflows rather than scattering logic across scripts.
Maintainable transformation
Mappings and business rules can be managed separately from transport concerns, making product-specific ADP structures easier to adapt as target schemas or API versions change.
Operational control
Martini provides a consistent place to apply secrets management, checkpoints, idempotency, retries, monitoring, and reconciliation across ADP integrations.
API-led reuse
Martini can expose a controlled normalized API for downstream systems while keeping ADP authentication, product variation, and source-specific details behind the integration boundary.
Frequently asked questions
ADP can be integrated through its product-specific REST APIs, selected event-notification capabilities, and applicable batch, asynchronous, or file-exchange mechanisms. Authentication generally uses OAuth 2.0, while data synchronization can be scheduled or event-driven depending on the product and available operations.
Yes. Martini can integrate with ADP by consuming ADP REST APIs, exposing endpoints for supported ADP event notifications, orchestrating scheduled workflows, transforming ADP payloads, and sending validated data to downstream applications. The exact implementation depends on the customer's ADP products and entitlements.
No. A dedicated ADP connector is not required. Martini can use ADP's confirmed native integration mechanisms, including product-specific REST APIs, OAuth 2.0 authentication, selected event notifications, and applicable batch or file-exchange endpoints.
Lonti does not charge an additional per-connector or per-vendor fee to integrate ADP. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from ADP, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
Use the API associated with the customer's ADP product and business process, such as Worker, Organization, Position, Pay Statement, Time Off Request, or Payroll Input capabilities. REST APIs are the primary approach; batch, asynchronous, file, and event mechanisms should be used only where documented for the selected product.
Martini can expose an API endpoint or workflow trigger for supported ADP event notifications. ADP event coverage is product-specific and limited to selected events, so the implementation must confirm delivery method, subscriptions, payload completeness, security, and retry behavior.
A Martini workflow can retrieve ADP collections on a schedule or respond to supported notifications, follow pagination, store checkpoints, and map nested ADP structures into canonical or target-specific models. It can apply effective-date, privacy, validation, and source-of-truth rules before writing downstream data.
Martini can distinguish authentication, authorization, rate-limit, transport, schema, and business-rule failures. Transient failures can use controlled retry and backoff, while duplicate notifications can be managed with event or object-based idempotency keys and target upserts. Batch workflows can isolate item-level failures from successful items.
Related Martini documentation
Workflows
Connect ADP with Martini
Use Martini to build maintainable ADP integrations around REST APIs, selected event notifications, scheduled synchronization, secure authentication, and reusable workflow orchestration.