Connect ADP Workforce Now to ChatGPT: Sync employee data and payroll

If you need to connect ADP Workforce Now to ChatGPT to automate employee onboarding, sync payroll configurations, or orchestrate time-off approvals, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and ADP's highly complex, event-driven HRIS infrastructure.

If your team uses Claude, check out our guide on connecting ADP Workforce Now to Claude and connecting ADP Workforce Now to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise HR platform is a serious engineering task. You either spend months building, hosting, and maintaining a custom MCP server to translate LLM arguments into ADP's OData payloads, or you use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

This guide breaks down exactly how to use Truto to generate a managed MCP server for ADP Workforce Now, connect it to ChatGPT, and execute complex HR workflows using natural language.

The Engineering Reality of the ADP Workforce Now API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against ADP's API requires deep domain knowledge of enterprise HR data structures.

If you decide to build a custom MCP server for ADP Workforce Now, you own the entire API lifecycle. Here are the specific integration challenges that break standard REST assumptions when working with ADP:

The Event-Driven Meta Pattern

ADP does not use standard REST CRUD operations. You cannot simply PUT /workers/123 to change a job title. Instead, ADP relies on an event-driven architecture. To change a record, you submit a specific event envelope (e.g., worker.work-assignment.modify).

Crucially, before you can submit that event, your system must often call a corresponding get_meta endpoint (e.g., adp_workforce_now_worker_work_assignment_get_modify_meta). This meta endpoint returns the specific OData schemas, valid transform templates, and required fields for that exact tenant. An AI agent must be trained to call the meta tool to discover the schema before attempting to call the action tool.

Complex Identifiers (AOIDs and PFIDs)

Standard APIs usually operate on a single primary key per user. ADP heavily partitions data across multiple identifiers. The most common is the Associate OID (AOID), which identifies the worker record. However, operations involving specific roles or assignments often require a Position File ID (PFID) or a specific Assignment ID. Your MCP server must maintain the relationships between these identifiers so the LLM can resolve a worker's email address to the correct internal AOID before adjusting their compensation.

Rate Limits and OData Pagination

ADP heavily relies on OData ($filter, $expand, $top, $skip) for data retrieval. Deeply expanded queries on large corporate directories are computationally expensive and strictly rate-limited.

A factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When ADP Workforce Now returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The AI agent or calling framework is strictly responsible for interpreting these headers and executing retry and backoff logic.

Generating the ADP Workforce Now MCP Server

Truto dynamically generates MCP tools based on the existing API documentation and configuration of the connected ADP Workforce Now account. You can create an MCP server either through the Truto dashboard or programmatically via the API.

Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to the integrated account page for your connected ADP instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. For example, limit the server to read operations if you only want ChatGPT to pull directory data, or filter by tags like payroll and workers to restrict the integration's scope.
5. Click Save. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>). Treat this URL as a secret, as it contains the authentication routing for that specific account.

Method 2: Via the Truto API

If you are provisioning ChatGPT access for multiple HR administrators dynamically, you can generate MCP servers programmatically.

Send a POST request to the /integrated-account/:id/mcp endpoint using your Truto API token. The configuration payload allows you to enforce strict method and tag filtering so ChatGPT only sees what it needs to.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ADP for ChatGPT HR Bot",
    "config": {
      "methods": ["read", "write"],
      "tags": ["workers", "time_off_requests", "work_assignments"]
    }
  }'

The API returns a database record containing the url field. This URL is ready for immediate use in ChatGPT.

Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you must register it with ChatGPT. You can do this via the ChatGPT application UI or through a manual configuration file for headless agent runners.

Method A: Via the ChatGPT UI

This method is ideal for ChatGPT Pro, Plus, Enterprise, or Education users with Developer mode enabled.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the MCP servers or Custom connectors section, click Add new server.
4. Name: Give the connector a recognizable label, like "ADP Workforce Now".
5. Server URL: Paste the Truto MCP URL you generated earlier.
6. Click Save. ChatGPT will immediately perform a protocol handshake and list the available ADP tools.

Method B: Via Manual Config File

If you are using a local runner, Claude Desktop, or a framework that requires a configuration file to proxy SSE connections, you can define the MCP server in a json configuration file.

Create a config file mapping the Server-Sent Events (SSE) transport to the Truto URL:

{
  "mcpServers": {
    "adp-workforce-now": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN"
      ]
    }
  }
}

When your client initializes, it will parse this configuration and expose the ADP tools directly to the agent's context.

Hero Tools for ADP Workforce Now

The ADP Workforce Now API is massive. Truto abstracts these endpoints into distinct, callable tools. Here are the highest-leverage tools available for your AI agents.

1. List All Workers

list_all_adp_workforce_now_workers

This tool retrieves the core employee directory. It returns the workers collection, crucially exposing each worker's associateOID, which is strictly required as an input parameter for almost all subsequent HR and payroll tools.

"Pull a list of all active workers in the engineering department and give me their associate OIDs and legal names."

2. View Team Time-Off Summaries

adp_workforce_now_time_off_requests_list_team_summaries

This tool allows a manager (identified by their AOID) to view the time off requests for their entire team. It supports OData $filter queries to narrow down requests by date ranges.

"Get the time off request summaries for the team reporting to manager AOID 987654321 for the month of July."

3. Retrieve Event Meta for Work Assignments

adp_workforce_now_worker_work_assignment_get_modify_meta

Because ADP is event-driven, the LLM must understand the schema rules before submitting a change. This tool returns the exact event metadata, field constraints, and valid code lists for modifying a worker's job title or function.

"Fetch the meta constraints for modifying a work assignment so I know what fields are required to update an employee's job title."

4. Modify Work Assignment

adp_workforce_now_worker_work_assignment_modify

Once the meta schema is understood, this tool executes the worker.work-assignment.modify event payload. This is the primary mechanism for processing employee promotions, department transfers, and job code changes.

"Submit a work assignment modification event for AOID 11223344 to update their job title code to SR-ENG-02."

5. Change Base Remuneration

adp_workforce_now_worker_compensation_change_base_remuneration

This tool handles salary updates by submitting the base remuneration change event. It accepts the JSON event body containing the new salary or hourly rate, effective dates, and currency codes.

"Process a base remuneration change for AOID 55443322, updating their annual salary to $120,000 USD effective next Monday."

6. Update US State Tax Instructions

us_tax_profiles_add_state_income_tax_instruction

A critical payroll operation. This tool submits the state tax withholding details for a worker, handling the complexities of adding a new state tax jurisdiction to a worker's US tax profile.

"Add a new state income tax instruction for PFID 99887766 for the state of New York using the provided withholding allowances."

To view the complete inventory of available tools, including data collection entries, schedule management, and custom field adjustments, visit the ADP Workforce Now integration page.

Workflows in Action

Integrating tools is only the first step. The true value of an MCP server is orchestrating multi-step workflows. Here is how ChatGPT handles complex ADP operations autonomously.

Workflow 1: Processing a Promotion and Salary Bump

Updating an employee's standing in ADP requires touching multiple systems. ChatGPT can string these tasks together seamlessly.

"Find Jane Doe in the system. Update her job title to 'Lead Developer' and process a base remuneration change to $145,000."

sequenceDiagram
    participant User as User
    participant Agent as ChatGPT Agent
    participant Truto as Truto MCP Server
    participant Upstream as Upstream API (ADP)

    User->>Agent: "Find Jane Doe. Update title to Lead Developer and salary to $145k."
    Agent->>Truto: Call list_all_adp_workforce_now_workers ($filter='Jane Doe')
    Truto->>Upstream: GET /hr/v2/workers?$filter=...
    Upstream-->>Truto: Return worker profile (AOID: ABC-123)
    Truto-->>Agent: Worker AOID
    Agent->>Truto: Call adp_workforce_now_worker_work_assignment_get_modify_meta
    Truto->>Upstream: GET /events/hr/v1/worker.work-assignment.modify/meta
    Upstream-->>Truto: Return event schema
    Truto-->>Agent: Allowed assignment fields
    Agent->>Truto: Call adp_workforce_now_worker_work_assignment_modify
    Truto->>Upstream: POST /events/hr/v1/worker.work-assignment.modify
    Upstream-->>Truto: 200 OK (Title updated)
    Truto-->>Agent: Success confirmation
    Agent->>Truto: Call worker_compensation_get_change_base_remuneration_meta
    Truto->>Upstream: GET /events/hr/v1/worker.base-remuneration.change/meta
    Upstream-->>Truto: Return compensation schema
    Truto-->>Agent: Allowed compensation fields
    Agent->>Truto: Call adp_workforce_now_worker_compensation_change_base_remuneration
    Truto->>Upstream: POST /events/hr/v1/worker.base-remuneration.change
    Upstream-->>Truto: 200 OK (Salary updated)
    Truto-->>Agent: Success confirmation
    Agent-->>User: "Jane Doe's title and salary have been updated successfully."

Workflow 2: Reviewing Team Schedules and Adjusting a Shift

Managers frequently need to audit team coverage and make tactical shift changes. ChatGPT handles the identifier resolution and event firing automatically.

"Pull the team work schedules for manager John Smith. Find the Friday shift for employee Mark Johnson and change the start time to 10:00 AM."

1. The agent calls list_all_adp_workforce_now_workers to resolve John Smith's AOID.
2. The agent calls adp_workforce_now_work_schedules_list_team using John's AOID to retrieve his team's schedule entries.
3. The agent searches the results for Mark Johnson's schedule and isolates the specific scheduleEntryId for the Friday shift.
4. The agent calls adp_workforce_now_work_schedules_get_change_meta to verify the payload structure.
5. The agent calls adp_workforce_now_work_schedules_change_entry with the exact scheduleEntryId and the updated 10:00 AM start time.

The manager gets an immediate confirmation that the schedule has been updated in the TLM (Time and Labor Management) system, all without opening a single ADP interface.

Security and Access Control

Granting an LLM access to HR data demands strict security controls. Truto provides multiple mechanisms to scope and secure your MCP servers at the token level:

• Method Filtering: Limit the server to specific operation types using config.methods. Restricting a server to ["read"] ensures the agent can query the employee directory but absolutely cannot modify payroll or demographics.
• Tag Filtering: Use config.tags to constrain the tools to specific operational domains, such as isolating the server strictly to time_off_requests rather than exposing full HR profiles.
• API Token Authentication: Set require_api_token_auth: true during creation. This enforces a secondary layer of security, requiring the calling client to provide a valid Truto API token in the header, protecting the endpoint even if the MCP URL leaks.
• Time-to-Live (TTL): Use the expires_at parameter to provision short-lived servers for automated, temporary audits, ensuring access is revoked the moment the window closes.

Wrap Up

Connecting ADP Workforce Now to ChatGPT unlocks powerful automation for your HR and payroll teams. By utilizing Truto to generate a secure, authenticated MCP server, you bypass the massive engineering overhead of maintaining OData parsers, event payloads, and complex authentication flows. Your team can stop writing custom boilerplate and start shipping intelligent, natural-language HR automations immediately.