Connect Pinpoint to ChatGPT: Manage Data and Automate Workflows

If you need to connect Pinpoint to ChatGPT to automate candidate sourcing, manage applications, or update interview scorecards, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Pinpoint's REST API. You can either spend weeks building and maintaining 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 Pinpoint to Claude or explore our broader architectural overview on connecting Pinpoint to AI Agents.

Giving a Large Language Model (LLM) read and write access to an Applicant Tracking System (ATS) is an engineering challenge. You must handle OAuth lifecycles, map deeply nested candidate relationships to MCP tool definitions, and deal with specific payload constraints. Every time an endpoint updates, 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 Pinpoint, connect it natively to ChatGPT, and execute complex recruitment workflows using natural language.

The Engineering Reality of the Pinpoint 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 2.0, the reality of implementing it against a modern ATS is painful. If you decide to build a custom Pinpoint ChatGPT integration, you own the entire API lifecycle.

Here are the specific integration challenges that break standard CRUD assumptions when working with Pinpoint:

The Relational Data Maze

Pinpoint's architecture relies heavily on relationships. A candidate object does not contain all of a job seeker's information in a flat JSON structure. Instead, a candidate is linked to applications, jobs, answers (custom questionnaire responses), scorecards, and comments. To effectively answer a prompt like "Give me a summary of John Doe's interview performance," an LLM cannot just hit one endpoint. It must first find the candidate, extract the application_id, fetch the application, identify the interview_id, and then fetch the interview details. If your MCP server doesn't clearly expose these relationship requirements in its schema definitions, the LLM will fail to sequence the API calls correctly.

HTML Payload Constraints

Unlike generic CRMs that accept raw text strings for notes, Pinpoint requires specific formatting for certain endpoints. For example, updating an interview summary via the update_a_pinpoint_interview_by_id endpoint requires the payload to be strictly formatted in HTML using specific allowed elements. If an LLM generates Markdown (its default behavior) and attempts to push it to Pinpoint, the API will reject the request. Your tool descriptions must explicitly enforce HTML generation, and your API execution layer must pass it cleanly.

Rate Limits and 429 Exhaustion

When an LLM starts crawling candidate lists or batch-updating applications, it will inevitably hit Pinpoint's API rate limits. It is critical to understand how this is handled: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Pinpoint API returns an HTTP 429 Too Many Requests, Truto acts as a transparent proxy and passes that error directly back to the caller.

However, Truto normalizes the upstream rate limit information into standardized IETF headers: ratelimit-limit, ratelimit-remaining, and ratelimit-reset. Your custom agent framework or ChatGPT's orchestrator is responsible for reading the ratelimit-reset value and applying the necessary sleep or backoff logic before retrying the tool call.

Generating a Managed Pinpoint MCP Server

Instead of building a JSON-RPC 2.0 server from scratch, you can use Truto to derive tool definitions dynamically from Pinpoint's endpoints. Truto uses the integration's resource definitions and human-readable documentation records to construct detailed JSON schemas for query and body parameters.

Each MCP server is scoped to a single integrated account. You can create the server via the UI or programmatically via the API.

Method 1: Via the Truto UI

For IT administrators and DevOps engineers who want to quickly provision a server for their workspace:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Pinpoint instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can filter tools by methods (e.g., read-only access) or by specific resource tags.
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...). This URL contains a hashed cryptographic token that handles authentication automatically.

Method 2: Via the Truto API

For integration builders who want to generate servers programmatically on behalf of their users, you can use the Token Management API. This is ideal for provisioning single-tenant AI agents.

Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Pinpoint Recruitment Agent",
    "config": {
      "methods": ["read", "write"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API validates that Pinpoint has documented tools available, generates a secure token stored in Cloudflare KV, and returns the endpoint URL. This URL is self-contained - the LLM client needs no additional API keys to execute operations against Pinpoint.

Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you must register it with ChatGPT so the underlying model can discover and execute the tools via JSON-RPC. This process allows you to bring custom connectors to ChatGPT without manual infrastructure management.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education accounts:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable the Developer mode toggle (MCP custom connectors are gated behind this flag).
3. Under the MCP servers / Custom connectors section, click Add new server.
4. Enter a recognizable name, like "Pinpoint ATS (Truto)".
5. Paste the Truto MCP server URL into the connection field.
6. Save the configuration.

ChatGPT will immediately send an initialize request to the URL, handshake with Truto, and pull down the full array of Pinpoint capabilities.

Method B: Via Manual Configuration File

If you are running a local orchestrator, a custom LangChain agent, or an alternative client like Claude Desktop, you connect the server by editing your MCP configuration file (mcp_config.json).

You must instruct the client to connect using Server-Sent Events (SSE) or stdio proxy wrappers:

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

Core Pinpoint Tools for AI Agents

Truto exposes dozens of endpoints as tools for Pinpoint. All tool arguments arrive as a single flat object, and the Truto MCP router intelligently splits them into query parameters and body payloads based on the integration schema.

Here are the highest-leverage hero tools your AI agent will use.

list_all_pinpoint_applications

This tool retrieves a list of candidate applications across jobs. It returns critical fields like candidate_id, job_id, stage_id, and hired_at. Pinpoint excludes confidential jobs by default unless explicitly requested via a filter parameter.

"Fetch the 10 most recent applications for the Senior Engineer role. Ignore confidential listings. Show me their current pipeline stages."

get_single_pinpoint_job_seeker_by_id

Job seekers represent the holistic profile of a person in your ATS. This tool accepts an id and returns structured data including first_name, email, summary, and relationships to answers, comments, and structured section responses.

"Look up the job seeker profile for ID 84920. Summarize their past experience and list any custom attributes attached to their profile."

create_a_pinpoint_application

This tool writes a new application into the system. It requires first_name, last_name, email, and a valid job relationship identifier. It returns the newly generated application_id and the default stage_id.

"Create a new application for Sarah Connor (sarah.c@example.com) for the Lead Designer role. Put her in the initial screening stage."

update_a_pinpoint_interview_by_id

This tool modifies an existing interview record. Note the specific constraint: you can only update the summary field, and it must be formatted in HTML using allowed elements.

"Update the interview record 10293. Add a summary stating that the technical screening went well and they are recommended for the onsite loop. Format the summary strictly in HTML using paragraph and bold tags."

create_a_pinpoint_comment

Comments are the lifeblood of ATS collaboration. This tool allows the LLM to leave notes on applications, job seekers, or candidates. It requires the body_text and the commentable relationship type and ID.

"Add a private comment to application ID 4401. State that the hiring manager has reviewed their portfolio and flagged it as a high-priority follow-up."

list_all_pinpoint_jobs

Before an LLM can assign a candidate to a requisition, it needs to find the correct internal ID for the job. This tool lists active jobs, returning the title, description, status, and relationship markers.

"List all open jobs in the Engineering department. Give me the internal job ID and compensation details for the Data Scientist requisition."

To view the complete tool inventory, including endpoints for scorecards, structured sections, requisition templates, and custom equality monitoring categories, visit the Pinpoint integration page.

Workflows in Action

Exposing individual REST endpoints to an LLM is only useful if the model can chain them together to execute autonomous workflows. Here is how ChatGPT utilizes the Truto MCP server to navigate Pinpoint's relational data.

Workflow 1: The Automated Recruiter Triage

Recruiters spend hours reviewing new applications and leaving initial triage notes. You can instruct ChatGPT to automate this preliminary review.

"Find the 5 most recent applications for the Account Executive job. For each application, look up the job seeker profile. If their summary mentions 'SaaS sales', add a comment to their application saying 'SaaS experience confirmed - ready for screening' and return a summary of their names."

Execution Steps:

1. list_all_pinpoint_jobs: The agent searches for the "Account Executive" job to find its job_id.
2. list_all_pinpoint_applications: The agent queries applications filtered by that specific job_id, limiting the return to 5 records.
3. get_single_pinpoint_job_seeker_by_id: For each returned application, the agent extracts the candidate_id and fetches the full job seeker profile to read the summary.
4. create_a_pinpoint_comment: When the condition is met, the agent constructs the payload and posts the comment linked to the specific application ID.

The user receives a concise confirmation summarizing the candidates who passed the logic gate, completely bypassing the manual UI clicks.

Workflow 2: Interview Loop Documentation

After a day of interviews, hiring managers often leave rough notes in Slack or Docs. An AI agent can parse these notes, find the corresponding interview record, and structure the data into Pinpoint.

"Find the interview scheduled for today with candidate ID 8821. Update the interview summary with the following notes: 'Strong technical communication. Needs to brush up on system design. Proceed to final round.' Make sure the summary is properly formatted in HTML."

Execution Steps:

1. list_all_pinpoint_interviews: The agent queries interviews associated with the specified interviewable_id (the candidate) to find the specific interview record for today.
2. update_a_pinpoint_interview_by_id: The agent formats the raw text into valid HTML (e.g., <p>Strong technical communication...</p>) and executes the PATCH request to update the summary field.

The user avoids copy-pasting notes across systems, and the ATS maintains a clean, standardized format.

Workflow 3: Sourcing and Requisition Matching

When a new role opens, you want to identify past "silver medalist" candidates who might fit the bill.

"List all open jobs. Find the new 'DevOps Engineer' requisition. Then, list all job seekers in the system who have the tag 'silver medalist'. Return a table matching the job seekers to the new role."

Execution Steps:

1. list_all_pinpoint_jobs: The agent retrieves the current active job roster and isolates the DevOps Engineer ID.
2. list_all_pinpoint_job_seekers: The agent queries the database, filtering by the specific custom attribute or tag.
3. The LLM processes the returned JSON schemas locally and generates a Markdown table for the user, presenting actionable sourcing leads.

Security and Access Control

Giving an AI agent write access to your production ATS requires strict guardrails. Truto's MCP architecture provides multiple layers of access control out of the box:

• Method Filtering: When generating the server, you can restrict access entirely to read operations. This exposes only get and list endpoints, ensuring the LLM cannot accidentally execute create_a_pinpoint_application or delete_a_pinpoint_candidate_by_id.
• Tag Filtering: You can group tools by tags. For example, you can create a server that only exposes tools related to jobs and requisitions, explicitly hiding sensitive scorecards and equality_monitoring data from the AI.
• Secondary Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting this flag to true, Truto forces the client to inject a valid Truto API token in the Authorization header. If the URL leaks, it remains useless without the secondary bearer token.
• Time-to-Live (expires_at): You can program servers to self-destruct. Setting an ISO datetime schedules a Durable Object alarm that permanently deletes the database record and Cloudflare KV entries. This is ideal for granting an external contractor short-lived AI agent access to your Pinpoint instance.

Architecting for Scale

Integrating AI agents with complex vertical SaaS platforms like Pinpoint exposes the fragility of custom-built connectors. You are not just building HTTP requests; you are translating abstract LLM intent into rigid, relational database operations while fighting rate limits and undocumented schemas.

Truto’s dynamic, documentation-driven MCP generation offloads this burden entirely. It acts as a stateless, highly available proxy that guarantees your AI agents always have accurate, up-to-date tool definitions without requiring you to write a single line of integration code. You stop managing boilerplate and start shipping autonomous workflows.