Connect Humand to ChatGPT: Manage HR Ops, Time Tracking & User Data

If you need to connect Humand to ChatGPT to automate HR operations, manage time-tracking entries, or orchestrate user provisioning, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Humand's REST APIs. You can either build, host, and maintain 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 Humand to Claude or explore our broader architectural overview on connecting Humand to AI Agents.

Giving a Large Language Model (LLM) read and write access to a comprehensive HR and operational platform like Humand is a massive engineering challenge. You have to handle complex relational data payloads, asynchronous bulk operations, and nuanced org-chart hierarchies. Every time an API schema drifts or a token expires, your custom server code must be updated and redeployed.

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

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::

The Engineering Reality of the Humand 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 Humand's API is exceptionally painful if you decide to build it in-house.

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

Merge-By-Type Semantics for Org Charts

Managing a company directory is never as simple as updating a flat user record. In Humand, updating an employee's position in the org chart relies on a specific upsert endpoint that uses merge-by-type semantics for relationships. If you want to update a user's manager, your MCP server must format an array of BOSS entries. If you send an empty array, it clears the manager. If you omit the BOSS key entirely, the existing manager remains untouched.

Exposing this to an LLM requires writing highly defensive JSON schemas. If the model decides to pass null for a relationship type it doesn't understand, it will accidentally wipe out that user's org-chart linkages. Truto handles this schema mapping automatically, presenting the LLM with explicitly documented required and optional fields.

Paired Entries for Time Tracking

When building time-tracking automations, you cannot simply send a boolean "clocked in" status. Humand's time-tracking architecture relies heavily on paired entries. A clock-in event and a clock-out event are tied together to calculate categorization, time-off overlap, and expected hours. If an LLM needs to resolve a missed punch, your MCP server must fetch the day's summary, identify the orphaned clock-in, and construct a paired update payload. Standardizing these temporal payloads into JSON-RPC tool definitions takes weeks of engineering trial and error.

Asynchronous Bulk Operations

Humand handles heavy operations - like bulk-creating time-off requests or shift assignments - asynchronously. When you submit a bulk payload, the API returns a bulk_id rather than the completed records. Your integration must then poll a separate job status endpoint to determine success or failure.

sequenceDiagram
    participant AI as AI Agent (ChatGPT)
    participant MCP as Truto MCP Server
    participant Humand as Humand API

    AI->>MCP: Call humand_time_off_bulk_create_requests
    MCP->>Humand: POST /time-off/bulk
    Humand-->>MCP: 202 Accepted { "bulk_id": "job_123" }
    MCP-->>AI: Returns job_123
    Note over AI,Humand: Agent must proactively check status
    AI->>MCP: Call humand_time_off_get_bulk_request_job(job_123)
    MCP->>Humand: GET /time-off/bulk/job_123
    Humand-->>MCP: 200 OK { "status": "completed" }
    MCP-->>AI: Returns completed records

Factual Note on Rate Limits

When executing high-volume tasks like bulk user updates, you will encounter rate limits. Truto does not retry, throttle, or apply backoff on rate limit errors. When the Humand API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. Your orchestrator or agent logic is responsible for parsing these headers and implementing retry/backoff.

Step-by-Step: Generate and Connect the Humand MCP Server

Truto abstracts away the authentication refresh cycles, schema generation, and routing. You connect the account once, and Truto generates a persistent, dynamic MCP endpoint.

Step 1: Create the MCP Server

You can generate an MCP server scoped specifically to a Humand environment using either the Truto dashboard or the API.

Method A: Via the Truto UI

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Humand account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict methods to read or write, or filter by tags like hr or time-tracking).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...). Treat this URL as a secure credential.

Method B: Via the Truto API Alternatively, you can generate the server programmatically. This is ideal if you are provisioning AI workspaces dynamically for your own users.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Humand HR Ops Server",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["users", "time_tracking", "shifts"]
    }
  }'

The API returns a database record containing the url. This URL encodes the authentication and routing logic required to execute tools against that specific Humand instance.

Step 2: Connect the MCP Server to ChatGPT

Now that you have the URL, you need to expose it to your LLM environment.

Method A: Via the ChatGPT UI If you are using ChatGPT (Pro, Plus, Team, or Enterprise) with Developer Mode enabled:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is toggled on.
3. Under MCP servers / Custom connectors, click Add new.
4. Give the connector a name (e.g., "Humand HR Ops").
5. Paste the Truto MCP Server URL into the Server URL field and save.

ChatGPT will immediately perform an MCP handshake (initialize), discover the available Humand tools, and make them available in your chat sessions.

Method B: Via Manual Config File (SSE) If you are running a local instance of Claude Desktop, Cursor, or a custom LangChain orchestrator, you can add the server via an MCP configuration file using the Server-Sent Events (SSE) transport.

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

Hero Tools for HR and Time Tracking Automation

Truto automatically derives MCP tool definitions from Humand's API documentation and schemas. Here are the highest-leverage tools available for orchestrating HR operations.

Upsert a User with Org Chart Semantics

Tool Name: humand_users_upsert_alt This tool allows you to update an existing user or create a new one while safely handling organizational relationships. Sending BOSS entries updates the org chart; omitting them leaves existing managers untouched.

• Required: password, employeeInternalId, firstName, lastName.
• Returns: The updated user object, status, and relationship mappings.

"Create a new employee profile for Jane Doe. Set her internal ID to EMP-992, assign her a temporary secure password, and set her BOSS relationship to point to EMP-104."

Create Paired Time-Tracking Entries

Tool Name: humand_time_tracking_create_paired_entries Use this tool to resolve missed punches by creating a paired clock-in and clock-out entry simultaneously.

• Required: A request body containing the paired entry inputs (start time, end time, employee ID).
• Returns: The created paired entry records.

"John Smith (EMP-405) forgot to clock out yesterday. Create a paired time-tracking entry for him starting at 9:00 AM and ending at 5:00 PM EST for yesterday's date."

Bulk Create Shift Assignments

Tool Name: humand_shifts_bulk_create Assigns shifts to multiple employees across multiple days in a single API call. Essential for generating weekly rosters based on historical patterns.

• Required: Array of employee shift assignments.
• Returns: A bulk process result indicating success or failure for each assignment.

"Take the attached CSV of next week's shift requirements and bulk-create the shift assignments in Humand for the engineering team."

Bulk Create Time-Off Requests

Tool Name: humand_time_off_bulk_create_requests Submits a batch of time-off requests for a specific policy. Because this is an asynchronous Humand endpoint, it returns a job ID rather than immediate results.

• Required: policy_id, array of request dates.
• Returns: A job accepted response containing the bulk_id.

"Submit mandatory company holiday time-off requests for all users under the US Full-Time policy (Policy ID: 882) for December 24th and 25th."

Track Bulk Job Status

Tool Name: humand_time_off_get_bulk_request_job Used in tandem with the bulk creation tool. Your agent must poll this endpoint using the returned job ID to confirm the time-off requests were successfully applied.

• Required: bulk_id.
• Returns: The status of the bulk creation job.

"Check the status of time-off bulk job 'bulk_job_9912'. If it has failed, list the specific employee IDs that triggered the error."

Create Goal Progress

Tool Name: humand_goals_create_progress Updates Key Performance Indicators (KPIs) or objective tracking for an employee by submitting new progress metrics against an existing goal.

• Required: goal_id, progress data.
• Returns: The created goal progress record.

"Update the Q3 Sales Target goal (Goal ID: 45) for employee EMP-211. Add $15,000 to the current progress metric and add a note saying 'Closed the Acme Corp deal'."

For a complete list of all available Humand endpoints, schemas, and return types, view the full inventory on the Truto Humand integration page.

Workflows in Action

When you connect Humand to ChatGPT via Truto, you move beyond single API calls into autonomous operational workflows. Here is how an AI agent strings these tools together to solve real HR problems.

Workflow 1: Autonomous Department and Shift Generation

An HR operations manager needs to stand up a new seasonal department, assign users, and generate their first week of shifts based on natural language instructions.

"Create a new department called 'Holiday Support'. Move employees EMP-301, EMP-302, and EMP-303 into this department. Once they are moved, bulk create shifts for all three of them for next Monday through Friday, 8 AM to 4 PM."

Step-by-Step Execution:

1. Create Department: The agent calls humand_departments_bulk_create with the name "Holiday Support".
2. Assign Users: The agent takes the returned department ID and calls humand_departments_add_members, passing the target ID and the array of employee internal IDs.
3. Assign Shifts: The agent formats the temporal payload and calls humand_shifts_bulk_create to assign the 8 AM - 4 PM shifts for the specified dates.

Result: The user gets a confirmation that the department was created, personnel were reassigned, and the roster is live - a process that normally takes 15 minutes of UI clicking done in seconds.

Workflow 2: Resolving Time-Tracking Anomalies

A payroll administrator asks ChatGPT to find and fix an employee's timesheet before the pay period closes.

"Pull the time tracking day summaries for employee EMP-109 for this week. If there are any days with a clock-in but no clock-out, assume they left at 5 PM and fix the record."

Step-by-Step Execution:

1. Audit Summaries: The agent calls humand_time_tracking_list_day_summaries, filtering by EMP-109 for the current week.
2. Identify Anomalies: The LLM parses the returned JSON, looking for objects where the time slot is open (missing an end boundary).
3. Patch Records: For the offending day, the agent calls humand_time_tracking_create_paired_entries, supplying the original start time and injecting the missing 5:00 PM end time.

Result: The payroll admin receives a concise summary of exactly which day was broken, the exact hours that were logged via the correction, and a confirmation that payroll can proceed.

Security and Access Control

Giving an LLM access to HR data requires strict boundary management. Truto MCP servers support multiple layers of programmatic access control:

• Method Filtering: When generating the server via the API or UI, you can pass config.methods: ["read"]. The server will only expose non-destructive get and list operations, stripping out tools like humand_users_deactivate entirely.
• Tag Filtering: You can restrict the server to specific operational domains. Passing config.tags: ["time_tracking"] ensures the agent can manage clock-ins but has zero visibility into goals or departments.
• Secondary Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting this flag to true, the client must also pass a valid Truto API token in the Authorization header, preventing lateral movement if the URL leaks in a configuration file.
• Automatic Expiry (expires_at): You can provision temporary MCP servers for contractors or auditing agents. Setting an ISO datetime ensures the underlying distributed key-value store automatically purges the token and schedules a cleanup routine when time expires.

Final Thoughts

Connecting Humand to ChatGPT using a custom integration requires untangling complex merge semantics, orchestrating async bulk jobs, and writing brittle JSON-RPC boilerplate. Truto's dynamically generated MCP servers eliminate this layer entirely. By mapping documentation directly to tool schemas, Truto provides your AI agents with real-time, authenticated access to HR and operational data with zero maintenance overhead.