---
title: "Connect Taleez to ChatGPT: Manage recruitment and candidates via MCP"
slug: connect-taleez-to-chatgpt-manage-recruitment-and-candidates
date: 2026-10-13
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Taleez to ChatGPT using Truto's MCP server. A complete engineering guide to automating candidate sourcing, job applications, and ATS pipelines."
tldr: "Connect Taleez to ChatGPT via a Truto-managed MCP server to automate recruitment tasks. This guide covers UI and API setup, security controls, and real-world tool-calling workflows for ATS data."
canonical: https://truto.one/blog/connect-taleez-to-chatgpt-manage-recruitment-and-candidates/
---

# Connect Taleez to ChatGPT: Manage recruitment and candidates via MCP


If you need to connect Taleez to ChatGPT so your AI agents can source candidates, parse resumes, orchestrate hiring pipelines, and update recruitment stages, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the secure translation layer between ChatGPT's function calls and the Taleez REST API. You can either spend weeks [building, hosting, and maintaining this infrastructure 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 an authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting Taleez to Claude](https://truto.one/blog/connect-taleez-to-claude-streamline-hiring-and-applications/) or explore our broader architectural overview on [connecting Taleez to AI Agents](https://truto.one/blog/connect-taleez-to-ai-agents-automate-candidate-workflows/).

Giving a Large Language Model (LLM) read and write access to an Applicant Tracking System (ATS) like Taleez is a significant engineering challenge. You must handle separated entity schemas, complex file upload mechanisms for resumes, and strict pagination rules. Every time the hiring team updates a candidate property or modifies the recruitment workflow, your custom server code must be updated, redeployed, and tested to prevent the LLM from hallucinating payloads.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Taleez, connect it natively to ChatGPT, and execute complex recruitment 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 Taleez API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models like GPT-4o to discover tools, implementing it against Taleez's highly specific ATS architecture is exceptionally painful. 

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

### Decoupled Candidates, Pools, and Applications
Unlike simpler CRMs where a "Contact" holds all relevant data, Taleez strictly decouples the human being (`Candidate`) from their engagement with the company (`Application`, `Pool`, `Spontaneous Application`). If an LLM needs to add a candidate to a specific role, it cannot just update a "job" field on the candidate object. The AI must first call the endpoint to create or fetch the candidate, retrieve the candidate's ID, and then construct a separate payload to create a `Job Application` linking that candidate ID to a specific `Job ID`. If your MCP tool schemas do not explicitly enforce this multi-step relational logic, the LLM will hallucinate single-step endpoints that do not exist.

### Two-Stage Document Uploads for Resumes
Taleez handles documents differently depending on the context. If you want an AI agent to upload a resume or cover letter, it often requires a two-step process involving the `tmp_documents` endpoint before attaching the file to a candidate record. Handling multipart/form-data for file uploads via standard JSON-RPC MCP tool calls requires your server to decode base64 file payloads from the LLM, buffer them, and stream them correctly to Taleez. 

### Custom Candidate Properties
Every organization customizes their Taleez instance with bespoke `candidate_properties`. The API exposes these as dynamic key-value pairs. A custom MCP server must dynamically read the `list_all_taleez_candidate_properties` endpoint, parse the metadata, and inject those exact property IDs into the LLM's prompt context so it knows how to format the `update_a_taleez_candidate_property_value_by_id` payload. Without this dynamic schema resolution, the LLM will guess the field names and the API will reject the request.

## Taleez to ChatGPT Quickstart Guide

If you want the fastest path from a fresh Truto account to ChatGPT successfully calling the Taleez API, follow these steps. We will cover two methods for creating the MCP server (UI and API) and two methods for connecting it to ChatGPT (UI and CLI).

**What you need:**
- A Truto account with API access.
- Taleez API credentials (API key) with appropriate permissions.
- A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode enabled.

### Step 1: Connect Taleez as an Integrated Account
First, establish the baseline connection in Truto. In the Truto dashboard, navigate to **Integrated Accounts -> New Integrated Account**, select Taleez, and input your API key. Truto manages the secure credential storage and handles all necessary authorization headers for downstream requests.

Make a note of your `integrated_account_id`. You can copy it directly from the Truto UI or retrieve it via the API:

```bash
curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"
```

### Step 2: Generate the Taleez MCP Server
Truto dynamically generates MCP tools based on the active API documentation for your connected integration. You can provision a server scope to this specific Taleez account via the UI or the API.

**Method A: Via the Truto UI**
1. Navigate to the integrated account page for your Taleez connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., restrict to `read` methods only, or filter by tags like `candidates` and `jobs`).
5. Click Save and copy the generated MCP server URL (formatted as `https://api.truto.one/mcp/<token>`).

**Method B: Via the API**
You can programmatically provision the MCP server by making a POST request. This is ideal for orchestrating agent infrastructure in code.

```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": "Taleez Recruitment Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["candidates", "jobs", "applications"]
    }
  }'
```

The response will return a `url` field containing your secure MCP endpoint. Treat this URL as a secret - it contains a cryptographically hashed token that inherently authenticates the request to your Taleez account.

### Step 3: Connect the MCP Server to ChatGPT
Now that you have your Truto MCP URL, you need to expose it to your LLM environment.

**Method A: Via the ChatGPT UI (Developer Mode)**
1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** to ON.
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. **Name**: "Taleez ATS"
5. **Server URL**: Paste your Truto MCP URL (`https://api.truto.one/mcp/<token>`).
6. Click **Save**. ChatGPT will perform a handshake, run the `tools/list` protocol, and immediately understand how to interact with Taleez.

**Method B: Via Manual Config File (SSE Transport)**
If you are using a local development environment, an agent framework, or testing via the Claude Desktop app before moving to ChatGPT, you can connect using a standard JSON config file leveraging the official `@modelcontextprotocol/server-sse` package.

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

## Hero Tools for Taleez Automation

[Truto automatically generates comprehensive tool schemas](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) for the Taleez API. Below are the highest-leverage hero tools your AI agent will use to automate recruitment ops. 

### list_all_taleez_jobs
This tool retrieves the list of open requisitions in your ATS. It handles Taleez's pagination system automatically. The LLM can use this to figure out which `job_id` it needs before attempting to assign a candidate to a role.

> "Fetch all open engineering roles in Taleez. I need the exact job IDs and their current status."

### create_a_taleez_candidate
This is the core write operation for adding new talent to the database. It accepts standard fields like first name, last name, email, and phone number. 

> "Add a new candidate named Sarah Jenkins. Her email is sarah.jenkins@example.com and she is based in London."

### create_a_taleez_job_application
Once a candidate exists and a job ID is known, the LLM uses this tool to explicitly link the two together, moving the candidate into the active hiring pipeline for that specific requisition.

> "Take candidate ID 14059 and apply them to the Senior Frontend Developer role (Job ID 832)."

### list_all_taleez_job_steps
Before an AI agent can advance a candidate through the pipeline, it needs to know what the pipeline looks like. This tool returns the custom workflow stages (e.g., "Phone Screen", "Technical Interview", "Offer") configured for a specific job.

> "What are the hiring stages for the Marketing Director position? List them in order."

### update_a_taleez_candidate_property_value_by_id
This tool allows the LLM to update custom metadata on a candidate record. If a recruiter asks the AI to update a custom "Willing to relocate" flag, the AI will use this tool to patch the specific property ID.

> "Update the 'willing_to_relocate' custom property to 'true' for candidate ID 9931."

### list_all_taleez_candidates
This tool allows the LLM to search the ATS for existing talent. It can filter by email or name to prevent creating duplicate candidate records when processing inbound resumes.

> "Search Taleez to see if we already have a candidate with the email alex.smith@domain.com. If so, return their candidate ID."

To view the complete schema definitions and the full list of available Taleez proxy APIs, visit the [Taleez integration page](https://truto.one/integrations/detail/taleez).

## Workflows in Action

When you give ChatGPT access to these tools, it stops acting as a simple text generator and becomes an autonomous recruitment operations agent. Here are two real-world workflows demonstrating how the LLM orchestrates multiple Taleez endpoints.

### Scenario 1: End-to-End Candidate Sourcing and Pipeline Assignment
An internal recruiter finds a great profile on LinkedIn, copies their basic details, and asks the AI to put them into the system for a specific role.

> "I found a great prospect named Marcus Wright (marcus.w@example.com, phone 555-0192). Add him to Taleez as a candidate, and then apply him to the open Backend Engineer role."

**Step-by-step Execution:**
1. ChatGPT calls `list_all_taleez_jobs` with a search filter for "Backend Engineer" to locate the correct Job ID.
2. ChatGPT calls `list_all_taleez_candidates` searching for "marcus.w@example.com" to ensure the candidate doesn't already exist.
3. Finding no duplicate, ChatGPT calls `create_a_taleez_candidate` using the provided name, email, and phone number, receiving `candidate_id: 4501` in return.
4. ChatGPT calls `create_a_taleez_job_application` using `candidate_id: 4501` and the previously discovered Job ID.

**Outcome:** The user receives a confirmation that Marcus is now in the system and actively applied to the Backend Engineer pipeline.

```mermaid
sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP
    participant TaleezAPI as Taleez API
    
    User->>ChatGPT: "Add Marcus Wright to the Backend role"
    ChatGPT->>TrutoMCP: Call list_all_taleez_jobs
    TrutoMCP->>TaleezAPI: GET /jobs?search=Backend
    TaleezAPI-->>TrutoMCP: Job ID 802
    TrutoMCP-->>ChatGPT: Job ID 802
    ChatGPT->>TrutoMCP: Call create_a_taleez_candidate
    TrutoMCP->>TaleezAPI: POST /candidates
    TaleezAPI-->>TrutoMCP: Candidate ID 4501
    TrutoMCP-->>ChatGPT: Candidate ID 4501
    ChatGPT->>TrutoMCP: Call create_a_taleez_job_application(4501, 802)
    TrutoMCP->>TaleezAPI: POST /applications
    TaleezAPI-->>TrutoMCP: Success
    TrutoMCP-->>ChatGPT: Application Created
    ChatGPT-->>User: "Marcus has been added and applied to the role."
```

### Scenario 2: Pipeline Audit and Custom Property Update
A hiring manager wants to do a bulk review of candidates in a specific stage and flag them for a follow-up action based on custom properties.

> "Find all candidates currently in the 'Technical Assessment' stage for the DevOps role. For any candidate who has been in this stage for more than a week, update their 'Needs Follow-Up' custom property to true."

**Step-by-step Execution:**
1. ChatGPT calls `list_all_taleez_jobs` to find the DevOps Job ID.
2. ChatGPT calls `list_all_taleez_job_steps` using the Job ID to find the exact Step ID corresponding to "Technical Assessment".
3. ChatGPT calls `list_all_taleez_candidate_applications` filtered by that specific Step ID, returning a list of candidates.
4. ChatGPT analyzes the timestamp of when they entered the stage. 
5. For candidates exceeding the 7-day mark, ChatGPT calls `list_all_taleez_candidate_properties` to locate the property ID for "Needs Follow-Up".
6. ChatGPT loops through the flagged candidates, calling `update_a_taleez_candidate_property_value_by_id` for each one.

**Outcome:** The hiring manager gets a plain-English summary of which candidates were flagged, while the underlying ATS database is cleanly updated without human data entry.

## Security and Access Control

Exposing an ATS to an autonomous AI agent introduces strict compliance and security requirements. Truto's MCP server architecture provides several mechanisms to lock down what ChatGPT can read or write in Taleez.

*   **Method Filtering:** When generating the MCP server, you can restrict it via `config.methods`. Passing `["read"]` ensures the LLM can only query candidates and jobs, completely neutralizing the risk of the AI accidentally modifying data or creating bogus applicants.
*   **Tag Filtering:** You can use `config.tags` to limit the server's surface area. For example, restricting tags to `["jobs"]` prevents the LLM from accessing candidate PII entirely.
*   **API Token Authentication:** By default, the Truto MCP URL acts as a bearer token. By enabling `require_api_token_auth: true`, you force the client to pass an explicit Truto API token in the authorization header. This means even if the MCP URL leaks in a slack channel, it cannot be used without valid environment credentials.
*   **Ephemeral Servers:** You can pass an `expires_at` ISO datetime when creating the server. Truto will automatically destroy the MCP token and its background durable object at the specified time - perfect for granting an AI agent temporary access during a specific hiring sprint.
*   **Rate Limits:** Truto does not silently retry or absorb HTTP 429 rate limit errors from Taleez. It passes them directly back to the caller while normalizing the `ratelimit-limit`, `ratelimit-remaining`, and `ratelimit-reset` headers per the IETF standard, ensuring the LLM or client framework is explicitly aware of API capacity.

## Rethinking ATS Integrations for AI

Connecting Taleez to ChatGPT transforms how recruitment teams interact with their data. Instead of navigating complex ATS UIs, clicking through tabs to find custom properties, or manually linking applicants to jobs, operators can simply instruct the system in natural language.

By leveraging Truto to generate the MCP server, engineering teams bypass the grueling work of managing ATS API schemas, handling multipart document uploads, and maintaining custom server infrastructure. You define the access scope, Truto handles the protocol translation, and your AI agents get to work immediately.