Connect Flatchr to Claude: Sync Recruitment Tasks and Candidate Data

If your team needs to connect Flatchr to Claude to automate recruitment pipelines, candidate sourcing, or hiring manager tasks, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude’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 ChatGPT, check out our guide on connecting Flatchr to ChatGPT or explore our broader architectural overview on connecting Flatchr to AI Agents.

Giving a Large Language Model (LLM) read and write access to an Applicant Tracking System (ATS) like Flatchr is an engineering challenge. You have to handle API token lifecycles, map massive JSON schemas for candidates and vacancies to MCP tool definitions, and deal with strict API quotas. Every time Flatchr updates an endpoint, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Flatchr, connect it natively to Claude Desktop, and execute complex hiring 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 over JSON-RPC, the reality of implementing it against specialized ATS APIs is painful.

If you decide to build a custom MCP server for Flatchr, here are the specific integration hurdles you will face:

Complex Multipart Form Submissions ATS platforms are heavily reliant on documents. Creating an applicant via the API is rarely a simple JSON payload. The Flatchr endpoint for creating candidates via the careers-site requires handling a multipart form submission where structured metadata (first name, last name, vacancy ID, custom screening questions) intersects with unstructured file uploads (resumes, cover letters). If you are building an MCP server from scratch, you must instruct the LLM on exactly how to format these payloads and build middleware to translate JSON tool calls into multipart HTTP requests.

Feature-Flagged Endpoints and Unique Identifiers Not all endpoints in the Flatchr API behave identically or use standard identifiers. For example, adding metadata to a candidate profile (flatchr_candidates_add_meta) requires the account to have the Premium CV Library option enabled. Furthermore, this specific endpoint uses the candidate's email address as the primary reference identifier rather than an internal UUID. An LLM has no context on these business rules. It will attempt to pass a UUID where an email is expected, resulting in immediate 400 errors. You must explicitly define these constraints in the tool's JSON Schema to prevent hallucinations.

State Machine Constraints Pipeline management in Flatchr relies on strict state transitions. Moving an applicant requires knowledge of the exact pipeline stage IDs. You cannot simply instruct an LLM to "change status to hired." The model must first query the available columns and channels, extract the correct internal IDs, and pass them to the applicant movement endpoint. A well-designed MCP server orchestrates these dependencies cleanly.

Generating the Flatchr MCP Server

Truto eliminates the need to build a custom translation layer. Instead of writing boilerplate code to map Flatchr's documentation to MCP tools, Truto derives tool definitions dynamically from the integration's resource schema and serves them over a ready-to-use JSON-RPC 2.0 endpoint.

There are two ways to generate a Flatchr MCP server using Truto: via the UI or programmatically via the API.

Method 1: Via the Truto UI

This is the fastest method for internal teams setting up Claude Desktop.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Flatchr instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can filter by methods (e.g., only read operations) or apply tag filters to limit access to specific resources (e.g., only vacancies).
5. Set an optional expiration date if this server is for temporary contractor access.
6. Click Create and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the API

If you are provisioning AI agents programmatically or building a multi-tenant SaaS application, you can generate MCP servers dynamically.

Send a POST request to the /integrated-account/:id/mcp endpoint with your desired configuration:

curl -X POST https://api.truto.one/integrated-account/flatchr_abc123/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Recruitment Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["applicants", "vacancies", "tasks"]
    }
  }'

The API validates that the integration has available tools, generates a secure, hashed token stored in a distributed key-value store, and returns a ready-to-use URL:

{
  "id": "mcp-789",
  "name": "Claude Recruitment Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

A Note on Rate Limits

When Claude begins executing loops and batch queries against Flatchr, you will inevitably hit rate limits. Truto does not retry, throttle, or apply backoff on rate limit errors. When Flatchr returns an HTTP 429, Truto passes that error directly to the caller.

However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (your agent framework or Claude) is responsible for reading these headers and executing the appropriate retry and backoff logic.

graph TD
  A["Claude Desktop"] -->|"JSON-RPC Tool Call"| B["Truto MCP Server"]
  B -->|"Validate Token & Context"| C["Truto Proxy Layer"]
  C -->|"REST Request"| D["Flatchr API"]
  D -.->|"HTTP 429 (Rate Limit)"| C
  C -.->|"Pass-through 429 + IETF Headers"| B
  B -.->|"JSON-RPC Error"| A

Connecting Flatchr to Claude

Once you have your Truto MCP server URL, connecting it to Claude requires zero code. You can connect it via the UI or through a manual configuration file.

Method A: Via the Claude or ChatGPT UI

If you are using an Enterprise or Team plan with custom connector support:

1. For Claude: Open Claude, navigate to Settings → Integrations → Add MCP Server. Paste the Truto MCP URL and click Add.
2. For ChatGPT: Open ChatGPT, navigate to Settings → Apps → Advanced settings. Enable Developer mode. Under custom connectors, add a new server, name it "Flatchr (Truto)", paste the URL, and click Save.

The UI will automatically negotiate the JSON-RPC handshake, and the LLM will discover all available Flatchr tools immediately.

Method B: Via Manual Config File

If you are using the Claude Desktop application locally, you can configure it via the claude_desktop_config.json file. Truto MCP servers support Server-Sent Events (SSE) transport, allowing you to use standard connection utilities.

Edit your configuration file (located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

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

Restart Claude Desktop. The model will initialize the connection and load the Flatchr toolset.

Hero Tools for Flatchr

Truto exposes dozens of Flatchr endpoints as tools. We curate these tools strictly from the integration's documentation—if an endpoint lacks a descriptive schema, it does not become a tool. This documentation-driven approach acts as a quality gate, ensuring Claude only sees endpoints with explicit instructions.

Here are the highest-leverage tools available for Flatchr workflows.

flatchr_applicants_search

This is the core discovery tool. It allows the LLM to search for candidates across the entire ATS based on name, email, tags, or vacancy IDs.

"Claude, search Flatchr for any applicants named 'Alex' who applied for the Senior Engineer role in the last 30 days."

flatchr_applicants_create_custom

This tool handles the complex multipart form submission required to ingest candidates through the public careers site. It accepts a vacancy ID, candidate name, comments, and specific screening question answers.

"Claude, create a new applicant profile for Jane Doe for the Marketing Manager vacancy. Include a comment that she was referred by the internal team."

flatchr_applicants_move

Managing the hiring pipeline requires shifting candidates between stages. This tool allows the LLM to transition an applicant through the ATS columns (e.g., from 'New' to 'Interviewing' to 'Hired').

"Move John Smith to the 'Technical Interview' column for the Frontend Developer vacancy."

flatchr_vacancies_list_active

Before taking action on applicants, the agent must understand the current state of the business. This tool returns a filtered list of all currently active job postings, their IDs, and metadata.

"List all active vacancies currently open in the engineering department."

create_a_flatchr_task

Recruitment is highly collaborative. This tool allows the LLM to create tasks assigned to specific recruiters or hiring managers, complete with deadlines and descriptions.

"Create a task for tomorrow reminding the hiring manager to review the technical assessment for Jane Doe."

flatchr_candidates_add_meta

This tool enriches existing candidate profiles. It explicitly requires the Premium CV Library option to be active on the Flatchr account and uses the candidate's email address as the primary reference key.

"Add a metadata tag indicating 'Strong Python Experience' to the candidate with the email alex@example.com."

To view the complete inventory of available tools, their JSON Schemas, and parameter definitions, visit the Flatchr integration page.

Workflows in Action

By chaining these tools together, Claude can execute complex, multi-step recruitment operations that would otherwise require manual data entry across multiple Flatchr screens.

Scenario 1: End-to-End Candidate Sourcing & Tasking

When a recruiter identifies a promising candidate on LinkedIn, they can instruct Claude to ingest the candidate and alert the team in one prompt.

"Find the active vacancy for 'Senior DevOps Engineer'. Then, create a new applicant named Sarah Connor for that vacancy. Finally, create a task for tomorrow assigned to the hiring manager to review her profile."

Step-by-step Execution:

1. flatchr_vacancies_list_active: Claude queries the active vacancies and filters the JSON response to locate the exact ID for the "Senior DevOps Engineer" role.
2. flatchr_applicants_create_custom: Claude calls the multipart form endpoint, passing the retrieved vacancy ID and Sarah Connor's details.
3. create_a_flatchr_task: Claude constructs a task payload with a timestamp for tomorrow, linking it to the newly created applicant ID, and posts it to Flatchr.

The recruiter receives confirmation that the candidate is tracked and the hiring manager's queue is updated.

sequenceDiagram
  participant User as Recruiter
  participant Claude as Claude Desktop
  participant MCP as Truto MCP Server
  
  User->>Claude: "Add Sarah to DevOps role and assign review task"
  Claude->>MCP: Call flatchr_vacancies_list_active
  MCP-->>Claude: Returns Vacancy ID
  Claude->>MCP: Call flatchr_applicants_create_custom
  MCP-->>Claude: Returns Applicant ID
  Claude->>MCP: Call create_a_flatchr_task
  MCP-->>Claude: Returns Task ID
  Claude-->>User: "Done. Sarah is added and task is scheduled."

Scenario 2: Pipeline Advancement and Enrichment

After a successful interview, the hiring manager wants to move the candidate forward and log key skills discussed during the call.

"Find the applicant with the email dev@example.com. Move them to the 'Offer Stage' and add metadata noting they passed the system design round."

Step-by-step Execution:

1. flatchr_applicants_search: Claude locates the specific candidate profile using the provided email address to extract their internal applicant ID.
2. list_all_flatchr_columns: Claude queries the pipeline schema to find the exact column ID that corresponds to "Offer Stage."
3. flatchr_applicants_move: Claude posts the movement request using the applicant ID and the column ID.
4. flatchr_candidates_add_meta: Claude targets the candidate's email (as required by this specific endpoint) to append the interview notes to the Premium CV Library metadata.

The candidate is seamlessly advanced through the ATS without the manager having to navigate the Flatchr UI.

Security and Access Control

When exposing HR data to an LLM, security is paramount. The Truto MCP token URL is cryptographically hashed, meaning the raw token is never stored in plain text. Beyond the inherent security of the token, Truto provides four critical controls to lock down your Flatchr MCP server:

• Method Filtering: Limit the server to specific operation types. By configuring methods: ["read"], Claude can list vacancies and search candidates, but cannot create, update, or delete records.
• Tag Filtering: Group tools by functional area. If Flatchr resources are tagged, you can restrict the MCP server to only expose tools tagged with vacancies, completely hiding the applicants endpoints from the LLM.
• Expiration (expires_at): Set a strict time-to-live for the server. Once the timestamp passes, the distributed cleanup scheduler automatically deletes the configuration, and the URL instantly revokes access.
• Extra Authentication (require_api_token_auth): For enterprise environments, possessing the URL is not enough. Enabling this flag forces the MCP client to also pass a valid Truto API token in the Authorization header, enforcing identity validation on every tool call.

Unblocking Recruitment Automation

Building an MCP server for Flatchr from scratch means taking on the burden of API maintenance, multipart form parsing, and OAuth token management. Every time a recruiter asks for a new automation, engineering time is burned maintaining the integration layer.

By generating a managed MCP server with Truto, you instantly bridge the gap between Claude’s reasoning capabilities and Flatchr’s strict data model. Your AI agents gain secure, curated access to recruitment workflows, and your engineering team avoids writing a single line of integration code.