Connect Manatal to Claude: Track Candidate Interactions and Files

If you need to connect Manatal to Claude to automate talent sourcing, track candidate interactions, and manage resume files, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool execution engine and Manatal's Applicant Tracking System (ATS) REST API. You can either spend weeks building and hosting this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL in seconds.

If your team uses ChatGPT, check out our guide on connecting Manatal to ChatGPT or explore our broader architectural overview on connecting Manatal to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling ATS ecosystem is an engineering challenge. You have to handle API token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with vendor-specific rate limits and pagination formats. Every time the vendor updates an endpoint or deprecates a field, 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 Manatal, connect it natively to Claude, and execute complex recruitment workflows using natural language.

The Engineering Reality of the Manatal 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 using JSON-RPC 2.0 messages, the reality of implementing it against a specific vendor's API is painful.

If you decide to build a custom MCP server for Manatal, you own the entire API lifecycle. You are not just integrating "an ATS" - you are integrating highly specific data structures with unique identifier requirements and file handling rules. Here are the specific challenges you will face:

Fragmented Identifier Schemas (candidate_id vs candidate_pk) Manatal does not use a universal ID format across all its endpoints. For many relational data models - like querying or updating candidate notes - the API requires the candidate_pk (an internal integer primary key). However, for document uploads like resumes or file attachments, the API expects the candidate_id (a standard UUID string). If you expose these raw API endpoints to Claude without explicit schema definitions, the LLM will constantly hallucinate the wrong identifier type, passing a UUID where an integer is expected, resulting in persistent 400 Bad Request errors. A managed MCP server strictly types these inputs in its generated JSON schemas to force the LLM into compliance.

Complex Multipart File Uploads Generating candidate attachments or uploading resumes in Manatal requires handling binary data via multipart/form-data requests. LLMs natively output text and JSON. They cannot construct raw binary payloads. If you build this yourself, you must write middleware that accepts a file URI or Base64 string from the LLM, fetches or decodes the binary content, constructs the proper boundary headers, and posts the payload to Manatal. Truto handles this translation natively within the proxy routing layer, allowing Claude to simply pass standardized JSON arguments that get converted into the required HTTP formatting.

Strict Rate Limiting and 429 Handling When an AI agent is instructed to "audit all candidate notes for the past year," it will rapidly execute pagination loops. This aggressive polling quickly triggers Manatal's API rate limits.

Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API like Manatal returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) following the IETF specification. The caller (in this case, your Claude instance or orchestration framework) is strictly responsible for implementing the necessary retry and exponential backoff logic. Do not assume your infrastructure absorbs these errors - your agent must be programmed to handle 429 responses gracefully.

How to Generate a Manatal MCP Server

Truto dynamically generates MCP tools based on the active API documentation and resource schemas defined in your integration configuration. This documentation-driven approach means tools are never cached or pre-built. When Claude requests the tool list, Truto iterates over every endpoint, applying any configuration filters, and building the schemas in real-time.

Each server is scoped to a specific integrated account. The server URL contains a cryptographic token that securely maps to the exact tenant instance of Manatal. You can generate this server via the UI or programmatically via the API.

Method 1: Generating via the Truto UI

If you want to manually provision a connection for a local Claude Desktop instance, the UI is the fastest route:

1. Navigate to the Integrated Accounts page for your Manatal connection in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can filter by allowed methods (e.g., restricting the server to only read operations) or filter by resource tags (e.g., only exposing candidates and notes). You can also specify an expiration date if you want the access to automatically revoke itself.
5. Copy the generated MCP server URL. It will look like https://api.truto.one/mcp/a1b2c3d4e5f6...

Method 2: Generating via the API

For production use cases where you are provisioning MCP servers dynamically for your end-users, you should use the API. This endpoint validates the configuration, generates the token, stores it in distributed KV storage, and returns the ready-to-use URL.

Endpoint: POST /integrated-account/:id/mcp

{
  "name": "Manatal ATS Recruiter Access",
  "config": {
    "methods": ["read", "write"],
    "tags": ["candidates", "notes", "documents"],
    "require_api_token_auth": false
  },
  "expires_at": "2026-12-31T23:59:59Z"
}

The response returns the token URL. Notice that the raw token is hashed immediately - even if the internal KV store was compromised, the raw access strings are secure.

{
  "id": "mcp-xyz-789",
  "name": "Manatal ATS Recruiter Access",
  "config": {
    "methods": ["read", "write"],
    "tags": ["candidates", "notes", "documents"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

How to Connect the MCP Server to Claude

Once you have the server URL, connecting it to Claude requires zero additional coding. The URL is entirely self-contained. The token embedded within it carries the routing context, tenant identification, and authentication state required to proxy requests securely to Manatal.

Method A: Connecting via the Claude UI

If you are using the consumer Claude interface (or ChatGPT), you can add the server directly from the settings menu:

1. Copy the MCP server URL you generated above.
2. In Claude, navigate to Settings -> Integrations -> Add MCP Server (Note: For ChatGPT users, the path is Settings -> Apps -> Advanced settings -> Developer mode -> Add custom connector).
3. Paste the URL into the server configuration field.
4. Click Add and save the configuration.

Claude will immediately execute an initialize handshake, followed by a tools/list request. Truto will parse the Manatal API documentation and return the filtered array of available tools. You can now start prompting Claude.

Method B: Connecting via Manual Configuration File

If you are running Claude Desktop or using a local AI agent orchestration framework like LangChain or LangGraph, you can configure the server manually using an SSE (Server-Sent Events) transport. Edit your claude_desktop_config.json file:

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

Restart Claude Desktop. The application will connect to the remote Truto server via SSE, establishing a persistent channel for JSON-RPC messages.

Manatal Hero Tools for Claude

When the LLM connects to the MCP server, it receives a flat array of tools. Truto dynamically converts Manatal's REST hierarchy into clear, actionable, snake_case tool names, merging query parameters and request bodies into a single input namespace for the LLM to process.

Here are the highest-leverage tools available for automating candidate workflows in Manatal:

list_all_manatal_candidate_notes

This tool retrieves the history of interactions, interview feedback, and internal recruiter notes for a specific candidate. It requires the integer candidate_pk. Truto automatically injects limit and next_cursor schema properties, explicitly instructing the LLM to pass cursor values back unchanged to prevent hallucinated pagination states.

"Fetch all the interview notes for the candidate with the primary key 48920. Summarize the technical feedback from the final round and tell me if there were any red flags regarding their system design knowledge."

create_a_manatal_candidate_note

This tool allows the agent to log new interactions directly into the ATS. It uses the candidate_id (UUID format). The tool accepts the note text and automatically logs the creator and timestamp. This is critical for agents acting as automated email processors or call summarizers.

"I just finished a screening call with the candidate (ID: a1b2c3d4-e5f6-7890-abcd-ef1234567890). They are looking for a base salary of $150k and require remote work. Create a new candidate note logging these compensation expectations."

delete_a_manatal_candidate_note_by_id

When an AI agent is managing candidate profiles, it occasionally needs to prune outdated, duplicate, or incorrect information. This tool requires both the candidate_pk and the specific note id. It returns a 204 No Content response to confirm the successful deletion of the record.

"Find the duplicate screening note on candidate PK 48920 that was created today by the automated system, and delete it so the recruiter timeline is clean."

create_a_manatal_candidate_attachment

This tool orchestrates file uploads to a candidate's profile. You must supply the candidate_id, the file URL, a name, and a description. Truto's proxy layer translates this JSON payload into the necessary multipart submission Manatal expects, returning the finalized attachment metadata.

"Take the code sample link provided in this chat and upload it as a new attachment to candidate ID a1b2c3d4-e5f6-7890-abcd-ef1234567890. Name the file 'Take-Home Assessment Code' and add a description noting that it was submitted on time."

create_a_manatal_candidate_resume

Similar to generic attachments, this tool specifically targets the resume upload endpoint using the candidate_id. Manatal treats resumes as specialized documents that trigger automated parsing and text extraction in the background. Uploading via this endpoint ensures the candidate profile is fully populated.

"The candidate provided an updated version of their CV via email. Upload this document URL as their new official resume under candidate ID a1b2c3d4-e5f6-7890-abcd-ef1234567890."

To view the complete inventory of available resources, query parameters, and JSON schemas, visit the Manatal integration page.

Workflows in Action

Exposing individual tools to Claude is useful, but the real value of an MCP integration comes from chaining these tools together to execute complex, multi-step operations. Here is how Claude handles real-world Manatal workflows.

Scenario 1: Candidate Interview Debrief and Cleanup

A recruiter needs to process disorganized feedback from a hiring panel, clean up duplicate placeholder notes, and finalize the candidate record.

"Review the existing notes for candidate PK 88392. Delete any short, automated placeholder notes created today. Then, summarize this raw interview transcript I just pasted into a single, cohesive technical evaluation note, and create that new note on the candidate's profile using their ID (b9c8d7e6-f5a4-1234-5678-90abcdef1234)."

Step-by-step Execution:

1. Claude calls list_all_manatal_candidate_notes using the provided candidate_pk to retrieve the current interaction timeline.
2. Claude analyzes the returned array of notes, identifying the ID of the placeholder note.
3. Claude calls delete_a_manatal_candidate_note_by_id using the candidate_pk and the specific note ID to remove the clutter.
4. Claude synthesizes the transcript text into a professional summary.
5. Claude calls create_a_manatal_candidate_note using the candidate_id, pushing the final, polished feedback into the ATS.

Result: The recruiter's ATS is automatically pruned of duplicate data, and the final interview feedback is securely logged without any manual data entry.

Scenario 2: Processing Supplementary Hiring Documents

A hiring manager receives a candidate's portfolio and a separate architecture diagram they drew during a technical round. The manager wants these assets correctly categorized and attached to the candidate profile.

"I have two links for candidate ID b9c8d7e6-f5a4-1234-5678-90abcdef1234. The first is their updated resume URL. The second is an architecture diagram they drew. Upload the resume using the official resume endpoint. Then, upload the diagram as a general candidate attachment named 'System Design Whiteboard'."

Step-by-step Execution:

1. Claude parses the instructions and the document URLs.
2. Claude calls create_a_manatal_candidate_resume, passing the candidate_id and the first URL. Truto manages the multipart boundary creation and pushes the document to Manatal's resume parser.
3. Claude receives the successful response containing the new resume ID and timestamp.
4. Claude calls create_a_manatal_candidate_attachment, passing the candidate_id, the second URL, the requested file name, and a generic description.

Result: The candidate's core resume is updated and their supplementary work product is safely archived in the ATS, organized neatly with clear file names.

Security and Access Control

When connecting an LLM to an enterprise HR and recruiting system like Manatal, security is critical. You cannot simply hand over a root API key. Truto's MCP architecture provides several layers of granular access control applied at the token level, preventing the LLM from executing unauthorized actions.

• Method Filtering: You can restrict a server configuration to only execute specific HTTP methods. Passing methods: ["read"] ensures the dynamic tool generator only creates tools for GET and LIST endpoints. The LLM physically cannot alter data because the write tools do not exist in its context.
• Tag Filtering: Integrations classify resources with specific functional tags. You can pass tags: ["notes"] to ensure the MCP server only exposes interaction tracking endpoints, walling off the LLM from accessing core directory profiles or sensitive compensation data.
• Required API Token Auth: By default, possessing the MCP server URL is enough to execute tools. Setting require_api_token_auth: true adds a secondary middleware layer. The client must supply a valid Truto session or API token via a Bearer header to proceed. This prevents unauthorized network actors from using the server even if they intercept the URL.
• Automatic Expiry: You can pass an ISO 8601 timestamp in the expires_at field. Truto will schedule a durable object alarm and bind the expiration to its internal KV storage. Once the timestamp passes, the token is permanently destroyed, killing the connection instantly.

Automate the ATS with Confidence

Connecting Manatal to Claude gives your AI agents the ability to navigate, audit, and update complex recruitment data without you writing a single line of OAuth logic or pagination middleware. By generating an MCP server through Truto, you ensure that the LLM operates within strictly defined, highly structured schemas.

With native translation of Manatal's unique ID structures, robust handling of multipart file attachments, and a protocol-compliant pass-through for 429 rate limit errors, you have a production-ready integration layer from day one.