---
title: "Connect Flatchr to ChatGPT: Manage Vacancies and Applicant Workflow"
slug: connect-flatchr-to-chatgpt-manage-vacancies-and-applicant-workflow
date: 2026-10-13
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Flatchr to ChatGPT using Truto's managed MCP server. This guide covers setup, tool execution, and complex ATS workflow automation."
tldr: "Connect Flatchr to ChatGPT via Truto's managed MCP server to automate recruitment pipelines, manage vacancies, and orchestrate applicant tracking workflows securely."
canonical: https://truto.one/blog/connect-flatchr-to-chatgpt-manage-vacancies-and-applicant-workflow/
---

# Connect Flatchr to ChatGPT: Manage Vacancies and Applicant Workflow


If you need to connect Flatchr to ChatGPT to automate recruitment pipelines, manage job vacancies, or orchestrate applicant tracking workflows, 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 translation layer between ChatGPT's tool calls and Flatchr's REST APIs. You can either build 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 Flatchr to Claude](https://truto.one/connect-flatchr-to-claude-sync-recruitment-tasks-and-candidate-data/) or explore our broader architectural overview on [connecting Flatchr to AI Agents](https://truto.one/connect-flatchr-to-ai-agents-automate-hiring-and-pipeline-operations/).

Giving a Large Language Model (LLM) read and write access to a modern Applicant Tracking System (ATS) like Flatchr is an engineering challenge. You have to handle complex relational payloads (mapping applicants to vacancies and columns), deal with polymorphic resume uploads, and strictly enforce data privacy for candidate information. Every time Flatchr updates its API schema, 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 Flatchr, 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 Flatchr 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 Flatchr's highly specific API is exceptionally painful. 

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

### Multipart Form Submissions for Candidates
Creating a candidate isn't always a simple JSON POST request. Many ATS workflows require submitting a candidate through the public careers-site multipart form (`flatchr_applicants_create_custom`). This endpoint blends structured ATS data (vacancy IDs), unstructured text (screening questions, comments), and binary file uploads (resumes) into a single payload. LLMs output JSON natively. Forcing an LLM to construct valid `multipart/form-data` payloads directly results in massive hallucination rates. Your MCP server must accept clean JSON-RPC from ChatGPT and translate it into a compliant multipart stream for Flatchr.

### Deeply Nested Board Operations (Kanban Columns)
Moving an applicant in Flatchr is not just updating a `status` string field. It requires interacting with the `flatchr_applicants_move` method, which depends on referencing specific Kanban `columns` and `vacancies`. When a recruiter tells an AI agent to "move John to the Interview stage," the LLM must first discover the available columns, map the semantic meaning of "Interview" to a specific UUID, and then construct the move request. Building static MCP schemas for this requires constant syncing with the user's specific board configuration.

### Context-Dependent Identifiers (Metadata Tagging)
Managing candidate metadata often requires specialized endpoints. For example, the `flatchr_candidates_add_meta` endpoint (which adds metadata to a candidate profile, often requiring the Premium CV Library option) expects a candidate reference via *email address* rather than the standard internal UUID used by other endpoints. Passing a UUID here will result in a 400 Bad Request. An intelligent MCP layer must clearly document these identifier differences in the JSON Schema descriptions so the LLM knows exactly which identifier to pass to which tool.

### Handling Rate Limits and Retries
When orchestrating multi-step workflows (like searching for 50 applicants and moving them across columns), you will hit Flatchr's rate limits. **Factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Flatchr API returns an HTTP 429, Truto passes that error directly to the caller (ChatGPT). Truto normalizes the upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller (your LLM client or agent framework) is strictly responsible for implementing retry and backoff logic.

## Step 1: Create a Flatchr MCP Server

Before ChatGPT can call Flatchr tools, you need an MCP server endpoint. Truto scopes every MCP server to a single integrated account, meaning the generated URL inherently knows which Flatchr tenant it is talking to. You can generate this URL via the Truto UI or the API.

### Method A: Via the Truto UI
1. Log into your Truto dashboard and navigate to **Integrated Accounts**.
2. Select your connected Flatchr integration.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., allow `read` and `write` methods, or filter by specific tags like `applicants`).
6. Copy the generated MCP server URL. It will look like `https://api.truto.one/mcp/<token>`.

### Method B: Via the Truto API
If you are building a platform that provides AI assistants to recruiters, you will want to generate these endpoints programmatically. Make a `POST` request to `/integrated-account/:id/mcp`.

```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 Flatchr Access",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["applicants", "vacancies"]
    }
  }'
```

The response returns a JSON object containing the secure URL. Truto hashes the underlying token before storing it in edge KV storage; the raw token is only ever visible in this initial response and within the URL itself. Treat this URL like a highly privileged secret, especially when handling [sensitive candidate data and privacy requirements](https://truto.one/blog/how-do-mcp-servers-handle-data-retention-and-security-for-ai-agents/).

## Step 2: Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can plug it into ChatGPT using either the UI (if you are using the ChatGPT web interface) or via a local configuration file (if you are running a custom agent or local client proxy).

### Method A: Via the ChatGPT UI
1. Open ChatGPT and navigate to **Settings** -> **Apps** -> **Advanced settings**.
2. Enable **Developer mode** (MCP support requires this flag to be toggled on).
3. Under the **MCP servers / Custom connectors** section, click to add a new server.
4. Enter a descriptive name (e.g., "Flatchr Integration").
5. Paste the Truto MCP URL into the **Server URL** field.
6. Click **Save**. ChatGPT will perform a protocol handshake (`initialize`) and instantly discover the available Flatchr tools.

*Note: Developer Mode is currently available on Pro, Plus, Business, Enterprise, and Education accounts.*

### Method B: Via a Local Configuration File
If you are building a custom wrapper, integrating with the Claude Desktop app, or using an open-source MCP client that requires a config file, you can bridge the remote SSE connection using the official MCP proxy utility:

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

## 7 Hero Tools for Flatchr Workflows

When ChatGPT handshakes with the Truto MCP server, Truto [dynamically derives the tool definitions](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) directly from the integration's documentation schemas. This ensures the LLM receives highly accurate JSON Schema descriptions, eliminating payload hallucinations. All tool arguments share a flat input namespace, which Truto intelligently splits into query and body parameters on the fly.

Here are the highest-leverage tools ChatGPT can now execute against Flatchr.

### flatchr_applicants_search
Searches the ATS for specific applicants using parameters like email, phone, or name. This is the critical first step in any candidate update workflow, as the LLM must retrieve the Flatchr `applicant_id` before taking action.

> "Find the applicant profile for john.doe@example.com in Flatchr and summarize his current status."

### flatchr_vacancies_list_active
Lists only the active job openings in the ATS. This tool automatically injects pagination schemas (`limit` and `next_cursor`). If there are hundreds of active roles, the LLM is explicitly instructed by the generated schema to pass the `next_cursor` back unchanged to fetch subsequent pages.

> "List all active Engineering vacancies. If there are more than 20, fetch the next page and give me a complete list."

### get_single_flatchr_vacancy_by_id
Retrieves the full, detailed profile of a specific job vacancy, including its description, requirements, and assigned recruitment team.

> "Get the full details for the Senior React Developer vacancy (ID: 8fa92b) and tell me who the hiring manager is."

### flatchr_applicants_create_custom
Creates a new candidate profile through the public careers-site multipart form endpoint. This tool handles the complex payload mapping, allowing the LLM to pass structured vacancy IDs, names, comments, and questionnaire answers in simple JSON.

> "Create a new applicant named Sarah Connor for the DevOps vacancy. Add a comment that she was sourced via LinkedIn and answer 'Yes' to the remote work question."

### list_all_flatchr_columns
Lists the kanban columns (stages) configured in the ATS workspace. Because stages like 'Screening', 'Interview', and 'Offer' have unique, custom UUIDs in every Flatchr environment, the LLM must call this tool to dynamically discover the correct ID before moving a candidate.

> "List all the recruitment columns in Flatchr so we know the correct ID for the 'Technical Interview' stage."

### flatchr_applicants_move
Moves a candidate from one recruitment stage to another. The LLM constructs a payload containing the `applicant_id` and the destination `column_id`.

> "Move the applicant John Doe to the 'Technical Interview' column for the DevOps vacancy."

### flatchr_candidates_add_meta
Adds internal metadata to a candidate's profile. Crucially, Truto's derived schema instructs the LLM that the candidate reference here must be an *email address*, not the standard ID. (Note: Requires the Premium CV Library option).

> "Add a metadata tag 'High Priority' to the candidate with the email jane.smith@example.com."

To view the complete inventory of available Flatchr tools, including tags, tasks, messages, and administrative configurations, visit the [Flatchr integration page](https://truto.one/integrations/detail/flatchr).

## Workflows in Action

Exposing these tools allows ChatGPT to act as a fully autonomous recruitment assistant. By combining tools, the LLM can execute complex, multi-step operations that would normally require a recruiter to click through dozens of UI screens.

### Workflow 1: The Automated Recruiter Screen
When an HR manager asks the AI agent to advance a candidate, the LLM must discover the candidate's ID, discover the board's structure, and execute the move.

> "Find the applicant john.doe@example.com. Check his current status, and if he is in the 'New' stage, move him to 'Phone Screen' for the active Senior Dev role."

```mermaid
sequenceDiagram
    participant User as User Prompt
    participant GPT as ChatGPT
    participant MCP as Truto MCP Server
    participant Flatchr as Flatchr API
    
    User->>GPT: "Find john.doe@example.com..."
    GPT->>MCP: Call flatchr_applicants_search<br>{"email": "john.doe@example.com"}
    MCP->>Flatchr: GET /applicants?search=john.doe...
    Flatchr-->>MCP: Returns applicant details
    MCP-->>GPT: Applicant ID payload
    
    GPT->>MCP: Call list_all_flatchr_columns
    MCP->>Flatchr: GET /columns
    Flatchr-->>MCP: Columns list
    MCP-->>GPT: Columns list payload
    
    GPT->>MCP: Call flatchr_applicants_move<br>{"applicant_id": "123", "column_id": "abc-456"}
    MCP->>Flatchr: POST /applicants/123/move
    Flatchr-->>MCP: 200 OK
    MCP-->>GPT: Success
    GPT-->>User: "John Doe has been moved to Phone Screen."
```

**What happens:**
1. ChatGPT calls `flatchr_applicants_search` to resolve the email address to an internal Flatchr ID.
2. ChatGPT calls `list_all_flatchr_columns` to map the semantic string "Phone Screen" to the actual UUID of that stage in the user's specific Flatchr environment.
3. ChatGPT calls `flatchr_applicants_move` using the discovered IDs to advance the candidate.
4. The user receives a natural language confirmation.

### Workflow 2: Vacancy Creation & Candidate Import
An agency recruiter wants to spin up a new req and immediately load a sourced prospect into it.

> "Create a new active vacancy for 'Lead Data Scientist' in the Paris office. Then, create a new applicant named Alice Dubois for this vacancy, adding a note that she requires visa sponsorship."

**What happens:**
1. ChatGPT calls `create_a_flatchr_vacancy` passing the title and location. It receives the new `vacancy_id` in the response.
2. ChatGPT calls `flatchr_applicants_create_custom`, injecting Alice's name, the newly generated `vacancy_id`, and mapping the visa sponsorship note into the comments field.
3. The user gets a summary indicating the job is live and Alice is loaded as the first prospect.

## Security and Access Control

Giving an AI agent access to a live ATS requires strict guardrails. Truto's MCP architecture [provides several layers of access control](https://truto.one/blog/how-do-mcp-servers-handle-data-retention-and-security-for-ai-agents/) directly on the generated token:

*   **Method Filtering:** When creating the server via `/integrated-account/:id/mcp`, you can restrict the token to `methods: ["read"]`. This prevents ChatGPT from ever hallucinating a `create` or `delete` operation on your Flatchr data.
*   **Tag Filtering:** Restrict the server to specific operational domains by passing `tags: ["vacancies", "candidates"]`. The server will dynamically prune any tools outside these boundaries.
*   **Expiration (`expires_at`):** You can bind the MCP server to a strict Unix timestamp. Once expired, the underlying edge KV token is automatically destroyed by a durable alarm, instantly severing ChatGPT's access.
*   **Additional Auth (`require_api_token_auth`):** For zero-trust environments, setting this flag to `true` forces the MCP client to pass a valid Truto API token in the `Authorization` header. This ensures that possession of the MCP URL alone is useless without active developer credentials.

## Stop Writing Custom AI Integration Code

Connecting ChatGPT to Flatchr shouldn't require weeks of parsing ATS documentation, handling rate limit headers, and wrestling with multipart form uploads. By leveraging a managed MCP infrastructure, you convert complex REST semantics into safe, LLM-ready JSON-RPC tools instantly.

Whether you need to auto-screen applicants, sync board stages, or manage massive vacancy lists, Truto handles the translation layer so you can focus on building intelligent agent behavior.

> Ready to give your AI agents secure, native access to Flatchr? Generate your first managed MCP server with Truto today.
>
> [Talk to us](https://truto.one/book-a-demo/)