---
title: "Connect Manatal to ChatGPT: Manage Candidate Notes and Documents"
slug: connect-manatal-to-chatgpt-manage-candidate-notes-and-documents
date: 2026-06-09
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Manatal to ChatGPT using a managed MCP server. Automate candidate notes, upload resumes, and track recruitment workflows with AI."
tldr: Connecting Manatal to ChatGPT requires translating LLM tool calls into Manatal REST API requests. This guide shows how to deploy a managed MCP server via Truto to securely expose candidate notes and resume endpoints to AI agents.
canonical: https://truto.one/blog/connect-manatal-to-chatgpt-manage-candidate-notes-and-documents/
---

# Connect Manatal to ChatGPT: Manage Candidate Notes and Documents


If you need to connect Manatal to ChatGPT to automate candidate profile management, upload resumes, or audit recruitment notes, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between ChatGPT's native tool calls and Manatal's REST APIs. You can either build, host, 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 Manatal to Claude](https://truto.one/connect-manatal-to-claude-track-candidate-interactions-and-files/) or explore our broader architectural overview on [connecting Manatal to AI Agents](https://truto.one/connect-manatal-to-ai-agents-automate-recruitment-notes-and-resumes/).

Giving a Large Language Model (LLM) read and write access to an Applicant Tracking System (ATS) like Manatal is an engineering challenge. You have to handle OAuth token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with specific error handling quirks. Every time the API 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 ChatGPT, 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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools, the reality of implementing it against vendor APIs - or [maintaining custom connectors for 100+ other platforms](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/) - is incredibly painful. 

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

**Handling Resumes and Binary Attachments**
LLMs generate text, but ATS platforms operate heavily on files. When an LLM wants to upload a resume to a Manatal candidate profile, it cannot easily stream a raw binary payload or an `application/pdf` file directly through a standard JSON-RPC tool call. The MCP server must act as a bridge, accepting a URL string for the document, fetching the file into memory, formatting it as a `multipart/form-data` payload, and pushing it to Manatal. Without this abstraction, the LLM will hallucinate file uploads and fail to actually attach the resume.

**Candidate Identification and Primary Keys**
Manatal relies on strict internal identifiers (`candidate_pk` or `candidate_id`) to associate notes and documents with the correct applicant. These are not always identical to public-facing identifiers. Your custom server needs to ensure that when an LLM asks to "add a note to John Doe's profile", it first performs a highly accurate search to resolve "John Doe" to the exact `candidate_pk`, and then explicitly passes that integer into the subsequent POST request. 

**Strict Rate Limits and HTTP 429 Errors**
Manatal enforces rate limits to protect their infrastructure. When an AI agent loops rapidly over candidate lists to summarize notes, it will inevitably hit a HTTP 429 Too Many Requests response. 

A critical architectural detail: Truto does not retry, throttle, or apply exponential backoff on your behalf. Truto operates as a transparent proxy layer. When Manatal returns a 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 - whether it is ChatGPT or your custom LangGraph agent - is strictly responsible for catching the 429 and implementing its own retry and backoff logic. Do not assume the infrastructure will magically absorb these errors.

## How to Generate a Managed Manatal MCP Server

Instead of writing and hosting custom protocol handlers, you can generate a fully functional MCP server using Truto. Truto [derives tool definitions dynamically](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) from the connected integration's resource schema. If an endpoint is documented, it becomes an AI-ready tool automatically.

There are two ways to generate an MCP server for Manatal: via the Truto UI or programmatically via the API.

### Method 1: Generating via the Truto UI

For IT administrators and ops teams, the fastest way to get a URL is through the dashboard.

1. Log into your Truto environment and navigate to the **Integrated Accounts** page.
2. Select your connected Manatal account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (name, allowed methods like `read` or `write`, tag filters, and expiration dates).
6. Click Save and **copy the generated MCP server URL**. It will look something like `https://api.truto.one/mcp/a1b2c3d4e5f6...`.

### Method 2: Generating via the Truto API

For developers automating workspace provisioning, you can generate MCP servers programmatically. 

Make a `POST` request to the `/integrated-account/:id/mcp` endpoint. The API validates the configuration, generates a secure cryptographic token, stores it in distributed edge caching for rapid validation, and returns a ready-to-use URL.

```typescript
// Example: Creating a Manatal MCP server restricted to read operations
const response = await fetch('https://api.truto.one/integrated-account/<manatal_account_id>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${TRUTO_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Manatal Recruiter Assistant",
    config: { 
      methods: ["read", "write"], 
      tags: ["candidates", "notes"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});

const mcpServer = await response.json();
console.log(mcpServer.url); // The URL to paste into ChatGPT
```

## Connecting the Manatal MCP Server to ChatGPT

Once you have the Truto MCP server URL, you must connect it to your LLM framework. The URL contains a hashed cryptographic token that encodes the specific integrated account, meaning the URL itself acts as the authentication layer. No extra configuration is needed on the client side.

### Method 1: Connecting via the ChatGPT UI

If you are using the ChatGPT desktop or web application, you can add the server directly as a custom connector.

1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Enable the **Developer mode** toggle (MCP support requires this flag).
3. Under the **MCP servers / Custom connectors** section, click **Add new server**.
4. **Name:** Enter a recognizable label (e.g., "Manatal ATS (Truto)").
5. **Server URL:** Paste the `https://api.truto.one/mcp/...` URL you copied earlier.
6. Save the configuration. ChatGPT will instantly perform a JSON-RPC handshake, execute a `tools/list` request, and populate the model with the available Manatal endpoints.

*(Note: For Claude Desktop users, you navigate to **Settings -> Integrations -> Add MCP Server**, paste the URL, and click Add.)*

### Method 2: Connecting via Manual Configuration File

If you are running a custom agent, Cursor, or an LLM framework that relies on a local JSON configuration file (like `claude_desktop_config.json`), you can bridge the remote Truto server using the official Server-Sent Events (SSE) proxy provided by the MCP specification.

Add the following object to your `mcpServers` configuration:

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

When your client initializes, it runs the `npx` command to establish an SSE connection to Truto's remote JSON-RPC endpoint. 

## Manatal Hero Tools for ChatGPT

When the MCP server initializes, Truto dynamically builds tool definitions based on the exact resources and documentation attached to your Manatal integration. It injects strict JSON schemas that instruct ChatGPT exactly how to format queries and bodies.

Here are 5 high-leverage hero tools your AI agent can immediately use to manage candidate data.

### 1. create_a_manatal_candidate_resume

uploading a resume is the critical first step in tracking a new candidate. This tool takes a `candidate_id` and a `resume_file` URL. The underlying proxy fetches the file from the URL and attaches it to the candidate's profile, bypassing the need for the LLM to process raw binaries.

**Usage note:** The LLM must be provided with a publicly accessible or pre-signed URL to the resume file in its context window before calling this tool.

> "I have a resume for candidate ID 8492 hosted at https://storage.example.com/resumes/john_doe.pdf. Please upload this file to their Manatal profile and confirm the upload timestamp."

### 2. create_a_manatal_candidate_attachment

Beyond resumes, recruiters deal with portfolios, interview scorecards, and offer letters. This tool allows the LLM to attach auxiliary files to a candidate record.

**Usage note:** You must specify `candidate_id`, `name`, `description`, and the `file` URL. The explicit `name` parameter ensures the document is clearly labeled in the ATS UI.

> "Take the compiled interview scorecard located at https://internal.company.com/files/scorecard_8492.pdf and attach it to candidate ID 8492. Name the attachment 'Technical Screen Scorecard' and add a description stating 'Passed with strong system design skills'."

### 3. create_a_manatal_candidate_note

Notes are the lifeblood of recruitment workflows. This tool creates a new text note on a candidate's timeline. 

**Usage note:** This is exceptionally useful for post-interview summaries. An agent can read a transcript, summarize the key takeaways, and inject the summary directly into the ATS.

> "Based on our conversation history, create a new note for candidate ID 8492. The note should say: 'Candidate passed the technical phone screen. Strong Python skills, but requires a higher salary band. Proceeding to onsite.'"

### 4. list_all_manatal_candidate_notes

To give ChatGPT contextual awareness of a candidate's history, it must read existing notes. This tool requires a `candidate_pk` and returns an array of note objects, including the `info` (text), `creator`, and `created_at` fields.

**Usage note:** If a candidate has dozens of notes, the proxy API handles pagination cursors natively, instructing the LLM to pass the exact `next_cursor` value back to fetch subsequent pages.

> "Retrieve all notes for candidate PK 8492. Summarize the feedback from their previous interviews and tell me if anyone has flagged concerns about their communication skills."

### 5. delete_a_manatal_candidate_note_by_id

For compliance and data hygiene (such as GDPR right-to-be-forgotten requests), you may need to purge specific notes. This tool accepts a `candidate_pk` and the specific note `id` to execute a hard delete.

**Usage note:** This is a destructive write operation. It is highly recommended to configure human-in-the-loop approval in your agent framework before allowing the LLM to invoke this tool.

> "Find the note ID 1048592 attached to candidate PK 8492 and delete it permanently. Confirm once the API returns a 204 success status."

*These are just 5 of the high-leverage operations available. For the complete list of endpoints, JSON schemas, and available parameters, view the [Manatal integration page](https://truto.one/integrations/detail/manatal).* 

## Workflows in Action

Exposing individual endpoints is just the foundation. The real value of an MCP server lies in enabling ChatGPT to orchestrate multi-step workflows. Here are two real-world scenarios.

### Workflow 1: The Post-Interview Enrichment

After an engineering interview, a hiring manager drops their rough notes into ChatGPT and asks it to formalize the feedback and push it to the ATS.

> "Here are my rough notes from the interview with candidate 8492: 'Good system design, knew microservices well, but struggled with the database indexing question. Recommended for next round.' Please read their past notes to see if database indexing was an issue before, formalize my feedback into a professional note, and add it to their profile."

**Step-by-step execution:**
1. The model calls `list_all_manatal_candidate_notes` with `candidate_pk: 8492` to fetch historical context.
2. The model analyzes the returned JSON array to check for past mentions of database indexing.
3. The model synthesizes the raw notes into a professional paragraph.
4. The model calls `create_a_manatal_candidate_note` to push the formalized feedback to the candidate's timeline.

**Result:** The recruiter sees a perfectly formatted historical summary and new feedback note appear in Manatal instantly, without the hiring manager ever logging into the ATS.

### Workflow 2: Automated GDPR Note Audits

HR compliance teams frequently need to ensure interview notes do not contain inappropriate or non-compliant language (e.g., discriminatory remarks or unauthorized PII).

> "Audit all notes for candidate PK 59201. If any note contains the word 'age' or 'health', delete that specific note and provide me with a summary of what was removed."

**Step-by-step execution:**
1. The model calls `list_all_manatal_candidate_notes` with `candidate_pk: 59201`.
2. The model parses the `info` field of every note, running semantic checks for the flagged terminology.
3. The model identifies note ID `49281` as non-compliant.
4. The model calls `delete_a_manatal_candidate_note_by_id` using the specific `id` to purge the record.
5. The model responds in the chat window with a summary of the compliance action taken.

**Result:** The HR team automates tedious compliance audits, ensuring the Manatal database remains clean and legally sound.

## Security and Access Control

Giving an LLM direct access to your ATS data is a massive security risk if not properly constrained. Truto's MCP architecture provides native guardrails that you configure at the server level, ensuring the model can never exceed its intended scope.

*   **Method Filtering:** You can restrict a specific MCP server token to only allow read operations (`get`, `list`). If you create a server with `config.methods: ["read"]`, the `create_a_manatal_candidate_note` tool will simply not exist in the LLM's context, making hallucinated writes impossible.
*   **Tag Filtering:** Integration resources are grouped by tags. You can restrict an MCP server to only expose tools tagged with `candidates`, ensuring the model cannot accidentally traverse into billing or account settings endpoints.
*   **Require API Token Auth:** By default, possessing the MCP URL is enough to access the tools. For enterprise security, setting `require_api_token_auth: true` forces the client to pass a valid Truto API session token via standard middleware. This adds a mandatory second layer of identity verification.
*   **Time-to-Live (TTL):** By passing an `expires_at` ISO datetime during server creation, you can generate temporary access credentials. Once expired, the underlying durable database alarm automatically purges the token from the edge cache, revoking the LLM's access instantly.

## Moving Beyond Manual Integration

Connecting Manatal to ChatGPT via a custom-built integration layer requires you to fight rate limits, translate file blobs to URLs, and constantly update JSON schemas when Manatal alters their API. It is a massive drain on engineering velocity.

By leveraging a [managed MCP server](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/), you offload the protocol handling, token management, and schema generation to [purpose-built infrastructure](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). Your AI agents get secure, curated, and highly reliable tools, and your engineering team gets to focus on building core product features.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} 
Ready to connect your AI agents to Manatal without the engineering headache? Talk to our team to see how managed MCP servers can accelerate your roadmap.
:::