---
title: "Connect HR WORKS to ChatGPT: Automate HR Admin & Time Tracking"
slug: connect-hr-works-to-chatgpt-automate-hr-admin-time-tracking
date: 2026-10-01
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect HR WORKS to ChatGPT using an MCP server. Automate employee time tracking, absences, and HR administration with natural language."
tldr: "Connect HR WORKS to ChatGPT using Truto's managed MCP server. Overcome HR WORKS API complexities like async job polling, custom identifiers, and rate limits to automate time tracking and leave requests directly from ChatGPT."
canonical: https://truto.one/blog/connect-hr-works-to-chatgpt-automate-hr-admin-time-tracking/
---

# Connect HR WORKS to ChatGPT: Automate HR Admin & Time Tracking


If you need to connect HR WORKS to ChatGPT to automate time tracking, [orchestrate employee onboarding](https://truto.one/blog/connect-bamboohr-to-chatgpt-automate-employee-onboarding-records/), or manage complex absence requests, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and the highly specific architecture of the HR WORKS REST API. You can either spend weeks [building, hosting, and maintaining this polling and routing logic yourself](https://truto.one/blog/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL in seconds.

If your team uses Claude, check out our guide on [connecting HR WORKS to Claude](https://truto.one/blog/connect-hr-works-to-claude-manage-hiring-onboarding-attendance/) or explore our broader architectural overview on [connecting HR WORKS to AI Agents](https://truto.one/blog/connect-hr-works-to-ai-agents-sync-payroll-expenses-hr-flows/).

Giving a Large Language Model (LLM) read and write access to an [enterprise Human Resources Information System (HRIS)](https://truto.one/blog/connect-hibob-to-chatgpt-manage-employee-records-hr-operations/) is a serious engineering challenge. HR WORKS has strict authentication patterns, highly nested response structures, and heavy reliance on asynchronous job polling. 

This guide breaks down exactly how to use Truto to generate a secure MCP server for HR WORKS, connect it natively to ChatGPT, and execute complex HR workflows using natural language.

::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"}
Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
:::

## The Engineering Reality of the HR WORKS 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 the HR WORKS API is exceptionally complex. If you decide to build a custom MCP server for HR WORKS, you own the entire API lifecycle. 

Here are the specific integration challenges that break standard CRUD assumptions when working with HR WORKS:

### Asynchronous Write Jobs and Polling
Unlike most SaaS APIs where a `POST` request immediately returns the created object, nearly all write operations in HR WORKS (creating absences, updating permanent establishments, logging expenses) are asynchronous. 

When you call `POST /v2/absences`, HR WORKS does not return the absence record. It returns a `202 Accepted` response containing a `jobId`. To know if the absence was actually created, your system must repeatedly poll the `/v2/absences/jobs/{jobId}` endpoint until it returns a `finished` status. If you are building an MCP server, you must either build an artificial blocking mechanism into your server to wait for the job, or expose the polling mechanism as a separate tool to the LLM. Truto solves this by exposing specific `get_single_hr_works_*_job_by_id` tools, allowing ChatGPT to handle the polling loop natively.

### Dynamic Person Identifiers
HR WORKS does not rely on a single user ID format. Depending on the endpoint, you might need a `uuid`, a `personId`, a `personnelNumber`, a `personLicenseNumber`, or a `personIdentifierForKiosk`. Many endpoints require you to explicitly pass a `personIdentifierType` parameter alongside the ID. If an LLM attempts to guess the ID type, the request will fail. Your MCP server must supply rigid JSON Schemas that explicitly define these identifier types so the LLM constructs the payload correctly.

### Non-Standard Pagination Formats
Most APIs return lists of data as a flat JSON array (e.g., `"data": [ { ... }, { ... } ]`). HR WORKS often returns paginated data as a single object keyed by the person identifier. 

For example, listing accumulated absences returns an object where the keys are UUIDs and the values are arrays of absence data. The LLM must be explicitly instructed on how to parse this dynamic key structure. Truto dynamically enhances the OpenAPI schemas derived from HR WORKS documentation to guide the LLM through parsing these responses.

### Strict Rate Limits and HTTP 429s
HR WORKS enforces rate limits on API calls. It is critical to note that **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream HR WORKS API returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. Your LLM agent framework (or ChatGPT itself) is strictly responsible for interpreting these headers and executing the retry backoff.

## Step 1: Connect HR WORKS to Truto

Before ChatGPT can talk to HR WORKS, you must establish an authenticated connection. Truto manages the underlying credential exchange and securely stores the API keys.

1. Log into your Truto dashboard.
2. Navigate to **Integrated Accounts** and click **New Integrated Account**.
3. Select **HR WORKS** from the integration list.
4. Provide your HR WORKS API credentials (Access Key and Secret).
5. Truto validates the credentials by calling the HR WORKS health check endpoint (`GET /v2/health-check`).
6. Once connected, note your `integrated_account_id`. This ID represents this specific HR WORKS tenant.

## Step 2: Generate the HR WORKS MCP Server

Truto dynamically generates MCP tools from the underlying HR WORKS integration definitions. You can create an MCP server scoped to your HR WORKS account via the Truto UI or via API.

### Method A: Via the Truto UI

1. Navigate to the Integrated Account page for your HR WORKS connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Give your server a name (e.g., "HR WORKS Admin Agent").
5. Select your configuration. You can filter tools by methods (e.g., `read`, `write`) or tags (e.g., `absences`, `persons`).
6. Click **Create** and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<secure-token>`).

### Method B: Via the API

You can dynamically provision an MCP server for HR WORKS using a single POST request. This is ideal if you are provisioning AI agents programmatically.

```bash
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": "ChatGPT HR WORKS Access",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["absences", "persons", "working_times"]
    }
  }'
```

The API validates the configuration, ensures tools exist for the requested tags, and returns a secure payload:

```json
{
  "id": "mcp_srv_8x9y0z",
  "name": "ChatGPT HR WORKS Access",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}
```

Treat the `url` as a secret. It contains a cryptographic token that securely routes requests to your specific HR WORKS tenant.

## Step 3: Connect the MCP Server to ChatGPT

Now that you have a secure MCP endpoint, you can connect it to ChatGPT. There are two primary ways to do this depending on how your team uses OpenAI.

### Method A: Via the ChatGPT UI (Custom Connectors)

If you have a ChatGPT Pro, Plus, Business, Enterprise, or Education account, you can add the server directly into the interface.

1. In ChatGPT, click your profile picture and navigate to **Settings** -> **Apps** -> **Advanced settings**.
2. Toggle **Developer mode** on (this enables MCP support).
3. Under **MCP servers / Custom connectors**, click **Add new server**.
4. **Name:** Enter a recognizable name like "HR WORKS Agent".
5. **Server URL:** Paste the Truto MCP URL (`https://api.truto.one/mcp/<token>`).
6. Click **Save**. ChatGPT will immediately ping the endpoint, execute an `initialize` handshake, and load the HR WORKS tools.

### Method B: Via Manual Config File (SSE Transport)

If you are running a custom ChatGPT interface, LangChain architecture, or an enterprise agent framework, you can connect using the standard MCP SSE transport. 

Create an `mcp-config.json` file:

```json
{
  "mcpServers": {
    "hr_works": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<token>"
      ]
    }
  }
}
```

When your agent initializes, it will send a `tools/list` JSON-RPC request to the Truto edge server, which dynamically generates the HR WORKS tools based on your configuration.

## Hero Tools for HR WORKS

Truto automatically exposes HR WORKS endpoints as LLM-ready tools. We combine query and body schemas into a single flat namespace, making it easy for ChatGPT to pass arguments. 

Here are 6 high-leverage hero tools for automating HR WORKS tasks. *(Note: This is a curated selection. For the complete tool inventory, visit the [HR WORKS integration page](https://truto.one/integrations/detail/hrworks)).*

### 1. list_all_hr_works_persons

Fetches employee base data (names and identifiers like `personId`, `personnelNumber`, and `uuid`) grouped by organization unit. This is critical for resolving human names to system IDs before executing other actions.

> "Find the HR WORKS personnel number for John Doe in the Engineering organization unit."

### 2. list_all_hr_works_absences

Lists absences per person in a date range. It returns data on absence types, dates, half-days, and status. It requires a `beginDate` and `endDate` no more than one year apart.

> "Get all approved absences for personnel number 10452 between June 1st and August 31st."

### 3. create_a_hr_works_absence

Initiates a bulk absence creation request. Because HR WORKS processes this asynchronously, this tool does not return the absence record. It returns a `jobId` that must be polled.

> "Submit a sick leave request for personnel number 10452 starting tomorrow and ending on Friday."

### 4. get_single_hr_works_absence_job_by_id

Checks the status of an asynchronous absence write. ChatGPT uses this tool iteratively to poll HR WORKS until the job status changes from `pending` to `finished`.

> "Check the status of absence write job ID 88392. If it's still pending, wait a moment and check again."

### 5. create_a_hr_works_person_working_time

Clocks a person in or out instantly. This tool operates synchronously and requires an `action` (either `clockIn` or `clockOut`) and a `person_identifier`.

> "Clock out personnel number 10452 for the day. Note that they are leaving 30 minutes early."

### 6. create_a_hr_works_expense_report

Initiates an asynchronous request to create travel expense reports. This handles receipts, advances, and date ranges.

> "Draft a new travel expense report for personnel number 10452 for their trip to Berlin from May 12th to May 15th."

For a full breakdown of all available endpoints and schemas, check the [HR WORKS integration page](https://truto.one/integrations/detail/hrworks).

## Workflows in Action

Here is how ChatGPT uses these tools in sequence to accomplish complex HR administration tasks.

### Scenario 1: Clocking In a Remote Employee

When a remote employee asks ChatGPT to clock them in, the LLM must first identify the user, execute the clock-in action, and verify the status.

> "I just started my shift. Can you clock me in and tell me how many hours I'm scheduled for today? My name is Sarah Jenkins."

```mermaid
sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP
    participant HRWorks as HR WORKS API

    User->>ChatGPT: "Clock me in, I'm Sarah Jenkins"
    ChatGPT->>Truto: call list_all_hr_works_persons
    Truto->>HRWorks: GET /v2/persons
    HRWorks-->>Truto: Return personnelNumber: 4921
    Truto-->>ChatGPT: Return personnelNumber: 4921
    ChatGPT->>Truto: call create_a_hr_works_person_working_time (action: clockIn)
    Truto->>HRWorks: POST /v2/persons/working-times/clock-in
    HRWorks-->>Truto: 200 OK (workingTime started)
    Truto-->>ChatGPT: Return success
    ChatGPT->>Truto: call list_all_hr_works_persons_today (personnelNumber: 4921)
    Truto->>HRWorks: GET /v2/persons/today
    HRWorks-->>Truto: Return target working time: 8 hours
    Truto-->>ChatGPT: Return 8 hours
    ChatGPT-->>User: "You are clocked in! You are scheduled for 8 hours today."
```

**What happens:** ChatGPT looks up Sarah's `personnelNumber`, uses the working time tool to clock her in synchronously, and then queries her daily schedule to report her target hours back to her.

### Scenario 2: Handling Asynchronous Absence Requests

HR WORKS handles absence requests asynchronously. ChatGPT must orchestrate the write request and subsequently poll the job status.

> "I need to take next Monday and Tuesday off for a vacation. Please submit the request."

```mermaid
sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP
    participant HRWorks as HR WORKS API

    User->>ChatGPT: "Submit vacation for next Mon/Tue"
    ChatGPT->>Truto: call create_a_hr_works_absence
    Truto->>HRWorks: POST /v2/absences
    HRWorks-->>Truto: 202 Accepted (jobId: 7748)
    Truto-->>ChatGPT: Return jobId: 7748
    
    Note over ChatGPT: LLM begins polling loop
    ChatGPT->>Truto: call get_single_hr_works_absence_job_by_id (id: 7748)
    Truto->>HRWorks: GET /v2/absences/jobs/7748
    HRWorks-->>Truto: 200 OK (status: pending)
    Truto-->>ChatGPT: Return status: pending
    
    Note over ChatGPT: LLM waits, then retries
    ChatGPT->>Truto: call get_single_hr_works_absence_job_by_id (id: 7748)
    Truto->>HRWorks: GET /v2/absences/jobs/7748
    HRWorks-->>Truto: 200 OK (status: finished)
    Truto-->>ChatGPT: Return status: finished
    ChatGPT-->>User: "Your vacation request has been successfully submitted to HR WORKS."
```

**What happens:** ChatGPT understands that the initial creation merely returned a `jobId`. It autonomously calls the job polling tool, receives a `pending` status, waits, and polls again until HR WORKS confirms the absence is `finished`.

## Security and Access Control

When connecting an AI agent to an HR system, security is paramount. Truto's globally distributed storage handles token validation securely, ensuring the actual raw MCP tokens are hashed before storage. 

You can strictly control what ChatGPT can do in HR WORKS using four configuration layers:

*   **Method Filtering:** By setting `methods: ["read"]` during server creation, you completely disable `create`, `update`, and `delete` tools. The LLM simply won't know those tools exist.
*   **Tag Filtering:** By passing `tags: ["absences", "working_times"]`, you restrict the server strictly to time-tracking functions, preventing the AI from accessing payroll or performance data.
*   **Time-to-Live (TTL):** By setting an `expires_at` ISO datetime when generating the server, Truto automatically schedules a cleanup alarm. Once the TTL hits, the server and all edge storage entries are wiped, instantly severing ChatGPT's access.
*   **API Token Authentication:** By enabling `require_api_token_auth: true`, the MCP server URL alone is no longer enough. ChatGPT must also pass a valid Truto API token in the `Authorization` header, adding a second factor of authentication for sensitive HR operations.

## Connect ChatGPT to HR WORKS Today

Connecting ChatGPT to HR WORKS using a custom-built MCP server means dealing with undocumented rate limits, complex polling loops, and brittle pagination parsing. Every time the HR WORKS API evolves, your server code has to change.

Truto eliminates this overhead. By dynamically generating tools from documentation records, managing the secure token lifecycle, and formatting JSON Schemas specifically for LLM consumption, Truto lets you focus on building agent workflows instead of maintaining API infrastructure.

::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"}
Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
:::