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. 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 or explore our broader architectural overview on connecting Flatchr to AI Agents.

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.

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.

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.

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:

{
  "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 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.

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."

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 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.