---
title: "Connect PeopleForce to ChatGPT: Automate HR, Hiring & Performance"
slug: connect-peopleforce-to-chatgpt-automate-hr-hiring-performance
date: 2026-10-07
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "A complete engineering guide to connecting PeopleForce to ChatGPT using an MCP server to automate core HR workflows, applicant tracking, and performance reviews."
tldr: "Learn how to auto-generate a secure PeopleForce MCP server and connect it to ChatGPT. This guide covers UI and API setup, custom field handling, and real-world HR automation workflows for your AI agents."
canonical: https://truto.one/blog/connect-peopleforce-to-chatgpt-automate-hr-hiring-performance/
---

# Connect PeopleForce to ChatGPT: Automate HR, Hiring & Performance

**PeopleForce in ChatGPT, in about a minute.** The best way to connect PeopleForce to ChatGPT is Elaichi: connect PeopleForce to Elaichi once, then add Elaichi to ChatGPT as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect PeopleForce.** Connect PeopleForce once in Elaichi. ChatGPT never gets more access than you have.
3. **Add Elaichi to ChatGPT.** In ChatGPT, open Plugins, press +, and paste https://api.elaichi.ai/mcp into Server URL. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=peopleforce) · [PeopleForce on Elaichi](https://elaichi.ai/connectors/peopleforce/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=peopleforce)

*Building PeopleForce into your own product? The guide below is for you.*

---

If you want to connect PeopleForce to ChatGPT so your AI agents can automate employee onboarding, screen recruitment candidates, process leave requests, and manage performance reviews, 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 tool calling capabilities and the PeopleForce REST APIs. You can either spend weeks building and hosting this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting PeopleForce to Claude](https://truto.one/blog/connect-peopleforce-to-claude-manage-lifecycle-leave-salaries/) or explore our broader architectural overview on [connecting PeopleForce to AI Agents](https://truto.one/blog/connect-peopleforce-to-ai-agents-sync-time-assets-recruitment/).

Giving a Large Language Model (LLM) read and write access to a comprehensive [HRIS and ATS platform like PeopleForce](https://truto.one/blog/what-are-hris-integrations-the-2026-guide-for-b2b-saas-pms/) is a significant engineering challenge. You have to handle complex nested data payloads, map dynamic custom fields for employees and candidates, and navigate an API surface that spans multiple versions simultaneously. Every time PeopleForce adds a new module or updates an endpoint, your custom server code must be updated, redeployed, and tested.

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

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the PeopleForce API

Building a custom MCP server means owning the entire API lifecycle. While the open MCP standard provides a predictable way for models to discover tools, implementing it against an enterprise HR platform's API is exceptionally painful. Here are the specific integration challenges you face when working with PeopleForce:

### API Version Fragmentation
PeopleForce's API is actively evolving, meaning different functional areas live on completely different API versions. Core HR employee data might be served on v3 endpoints, legacy compensation tools on v2, and organizational structures (departments, divisions) on v4. If you build a custom MCP server, you have to hardcode the versioning logic for every distinct resource. Truto abstracts this away, [generating tools](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) derived from the precise API versions documented by the vendor, exposing a unified tool surface to the LLM.

### The Custom Field Mapping Problem
Unlike SaaS platforms with static endpoints, HR systems heavily rely on custom fields. In PeopleForce, custom fields for employees and candidates are not top-level JSON keys. Instead, they are returned inside a `custom_fields` object keyed by an `internal_name`. If an LLM needs to query an employee's custom "Shirt Size" for onboarding, it first needs to query the field definition endpoints (e.g., `/employee_fields`) to discover the `internal_name`, then map that key to the employee record. Truto's auto-generated documentation schemas teach the LLM exactly how to traverse these custom field structures without hardcoding.

### Soft Deletes vs Hard Deletes
When an LLM agent needs to remove a record, the behavior in PeopleForce changes drastically depending on the entity. Deleting a `team_member` performs a hard delete, while deleting a `team` or `department` performs a soft delete (keeping the record in the database but marking it inactive). If your LLM attempts to fetch a soft-deleted record later, it will still receive a 200 OK response with a deactivated state, rather than the 404 Not Found it might expect. This nuance requires explicit tool descriptions to prevent agent hallucinations.

### Strict Rate Limiting (And Why You Must Handle It)
Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream PeopleForce API returns an HTTP 429 (Too Many Requests), 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`). This is a critical architectural choice: the caller (your agent framework or ChatGPT client) is entirely responsible for executing retry and exponential backoff logic. Do not expect the MCP server to absorb rate limit errors.

## Quickstart: Creating a PeopleForce MCP Server

Truto scopes every MCP server to a single integrated account. This means the authentication and tenant context are baked directly into the connection. You can generate a PeopleForce MCP server using either the Truto UI or the API.

### Method 1: Via the Truto UI

If you prefer a visual setup, you can generate the server directly from your dashboard:

1. Navigate to the **Integrated Accounts** page in your Truto dashboard.
2. Click on the connected PeopleForce account you want to use.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., naming the server, filtering by allowed methods like `read` or `write`, and selecting specific feature tags).
6. Copy the generated MCP server URL. Treat this URL like a secure password.

### Method 2: Via the Truto API

For teams building automated agent provisioning, you can generate the MCP server programmatically. You will need your Truto API token and the `integrated_account_id` for the PeopleForce connection.

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "PeopleForce HR Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["core-hr", "recruitment", "performance"]
    }
  }'
```

The API will return a JSON payload containing the secure URL:

```json
{
  "id": "mcp_abc123",
  "name": "PeopleForce HR Agent",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}
```

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to ChatGPT takes less than a minute. You can configure this through the ChatGPT interface or via a local configuration file if you are running an Enterprise desktop setup.

### Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** to ON (this is required to expose MCP features).
3. Under the **MCP servers / Custom connectors** section, click **Add new server**.
4. Enter a recognizable name (e.g., "PeopleForce (Truto)").
5. Paste the Truto MCP URL you generated earlier into the Server URL field.
6. Click **Save**. ChatGPT will immediately connect, perform an initialization handshake, and list the available PeopleForce tools.

### Method B: Via Local Configuration File

If you are using a local agent framework or an MCP-compliant desktop client that relies on a configuration file, you can connect using the Server-Sent Events (SSE) transport. 

Add the following to your `mcp.json` or equivalent configuration file:

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

## Hero Tools for PeopleForce Automation

Truto exposes the entirety of the PeopleForce API as MCP tools. For this guide, we are highlighting six high-leverage "hero tools" that enable end-to-end HR and recruitment automation. 

*Note: Do not prompt the LLM to guess endpoints. Provide it with clear instructions on which tools to use.* 

### 1. List Employees (v3)

**Tool Name:** `list_all_people_force_employees`

This tool retrieves the core employee directory. It supports filtering by status (active/terminated), emails, employee numbers, and managers. It returns comprehensive records including `employment_type`, `department`, `job_level`, and `reporting_to`.

> "Use `list_all_people_force_employees` to find all active employees in the Engineering department who report to manager_id '12345'. Extract their employee IDs and email addresses."

### 2. Create a Recruitment Candidate

**Tool Name:** `create_a_people_force_recruitment_candidate`

Creates a new candidate in the ATS module. It accepts a name, email, phone numbers, cover letter text, and a resume URL. The API auto-matches duplicates based on email and CV parsing.

> "Take the attached resume text and extract the candidate's name and email. Use `create_a_people_force_recruitment_candidate` to add them to PeopleForce, including a short summary of their skills in the cover_letter field."

### 3. List Pending Leave Requests

**Tool Name:** `list_all_people_force_leave_requests_pendings_pending`

Retrieves all time-off requests currently awaiting approval. This is essential for building an automated manager-approval workflow or a daily HR digest.

> "Call `list_all_people_force_leave_requests_pendings_pending` to get all leave requests awaiting approval. Summarize them in a table showing the employee ID, leave type, hours requested, and dates."

### 4. Create a Timesheet Entry

**Tool Name:** `create_a_people_force_time_timesheet_entry`

Logs tracked time for a specific employee. It requires the `employee_id`, start time, end time, and an optional comment. 

> "The user 'John Doe' (employee_id: 887) said he worked from 9 AM to 5 PM today on the Q3 Migration project. Use `create_a_people_force_time_timesheet_entry` to log these hours, and add his comment about completing the database schema."

### 5. Update Employee Skills

**Tool Name:** `create_a_people_force_employee_skills_employee`

Adds a specific skill and proficiency level to an employee's talent profile. This is highly useful for automated performance review summaries or certification tracking.

> "Based on the certification document provided, use `create_a_people_force_employee_skills_employee` to add the 'AWS Certified Solutions Architect' skill (skill_id: 42) at proficiency level 'Expert' for employee_id 112."

### 6. Schedule an Employee Termination

**Tool Name:** `create_a_people_force_employee_terminate`

Schedules an employee for offboarding. It sets the termination effective date, termination type, and reason. It automatically updates their status on the effective date.

> "Use `create_a_people_force_employee_terminate` to schedule the offboarding for employee_id 305. Set the effective date to next Friday, use termination_reason_id 4 (Voluntary Resignation), and mark them as eligible_for_rehire."

[View the complete PeopleForce tool inventory and schema definitions in the Truto Integration Directory.](https://truto.one/integrations/detail/peopleforce)

## Workflows in Action

Connecting tools is only half the battle. The real power of an MCP server is orchestrating multi-step workflows. Here are two concrete examples of how ChatGPT can automate complex PeopleForce operations.

### Scenario 1: Automated Candidate Pre-Boarding

When a candidate accepts an offer, HR typically spends hours copying data from the ATS module into the Core HR module to create the employee profile. ChatGPT can completely automate this transition.

> "A candidate named Jane Smith just accepted our offer. Find her in the recruitment module, extract her details, and create a new active employee profile for her starting next Monday. Assign her to the Sales department."

**How the agent executes this:**

1. **Search Candidates:** ChatGPT calls `list_all_people_force_recruitment_candidates` with `email="jane.smith@example.com"` to retrieve her candidate ID and custom fields.
2. **Get Department ID:** It calls `list_all_people_force_departments_v_4` and filters the response to find the ID for the "Sales" department.
3. **Create Employee:** It calls `create_a_people_force_public_employees_v_3`, passing in Jane's first name, last name, email, department ID, and a `hired_on` date set to next Monday.
4. **Report Back:** The agent returns the newly created `employee_id` and confirms the profile is active.

```mermaid
sequenceDiagram
    participant User
    participant GPT as ChatGPT
    participant Truto as Truto MCP
    participant PF as "PeopleForce API"

    User->>GPT: "Jane Smith accepted the offer. Convert her to an employee in Sales."
    GPT->>Truto: Call list_all_people_force_recruitment_candidates (email: jane...)
    Truto->>PF: GET /v3/recruitment/candidates?email=...
    PF-->>Truto: Candidate Data
    Truto-->>GPT: Candidate Data
    GPT->>Truto: Call list_all_people_force_departments_v_4
    Truto->>PF: GET /v4/departments
    PF-->>Truto: Department Array
    Truto-->>GPT: Department Array
    GPT->>Truto: Call create_a_people_force_public_employees_v_3
    Truto->>PF: POST /v3/employees (Payload)
    PF-->>Truto: New Employee ID
    Truto-->>GPT: Success (ID: 9942)
    GPT-->>User: "Jane Smith is now an active employee starting next Monday."
```

### Scenario 2: Weekly Leave & Timesheet Audit

Managers often struggle to reconcile timesheets with approved leave. An AI agent can audit the week's data and flag discrepancies instantly.

> "Audit the timesheets and leave requests for the Engineering team from last week. Tell me if anyone logged hours on a day they had approved time off."

**How the agent executes this:**

1. **Fetch Team Members:** ChatGPT calls `list_all_people_force_teams_v_3` to find the Engineering team, extracting the `user_id` array.
2. **Fetch Leave:** It calls `list_all_people_force_leave_requests` using the date range filters to pull approved absences for those specific users.
3. **Fetch Timesheets:** It calls `list_all_people_force_time_timesheet_entries` for the same date range.
4. **Analyze:** The LLM cross-references the dates. If it finds a timesheet entry logged on a date marked as `state: "approved"` in the leave request array, it generates a discrepancy report.

## Security and Access Control

When exposing a sensitive HR system to an LLM, security is paramount. Truto's MCP servers provide granular controls to restrict what an agent can see and do.

*   **Method Filtering (`methods`):** When generating the MCP server, you can restrict the token to specific HTTP verbs. Setting `methods: ["read"]` ensures the agent can only call GET and LIST tools. It physically cannot execute POST, PATCH, or DELETE tools, eliminating the risk of accidental data modification.
*   **Tag Filtering (`tags`):** You can limit the server to specific API domains. Passing `tags: ["recruitment"]` ensures the LLM only sees tools related to the ATS. It won't even know the core HR or payroll endpoints exist.
*   **Extra Authentication (`require_api_token_auth`):** By default, possessing the MCP URL grants access. By setting `require_api_token_auth: true`, the connecting client must also pass a valid Truto API token in the headers. This prevents unauthorized access if the MCP URL is leaked in a configuration file.
*   **Auto-Expiration (`expires_at`):** You can set an exact ISO datetime for the server to self-destruct. This is perfect for giving a contractor or a temporary AI agent short-lived access to PeopleForce data without having to remember to revoke it manually.

## Strategic Wrap-up

Connecting PeopleForce to ChatGPT natively via MCP transforms HR from a system of record into an active, conversational participant in your business. By using Truto to generate the server, you skip the grueling process of mapping dynamic custom fields, hardcoding endpoint versions, and maintaining authentication lifecycles. 

Instead of writing boilerplate infrastructure, your engineering team can focus immediately on building agentic workflows that save HR and recruitment teams hundreds of hours a month.

Ready to automate your PeopleForce workflows? 

> Get a demo of Truto's SuperAI and generate production-ready MCP servers for PeopleForce in minutes.
>
> [Talk to us](https://truto.one/book-a-demo/)