Connect Pinpoint to Claude: Query Records and Sync Information

If your team needs to connect Pinpoint to Claude to query candidate records, orchestrate interview schedules, or automate recruiter workflows, you need a Model Context Protocol (MCP) server. This infrastructure layer acts as a translator between Claude's function calling capabilities and Pinpoint's underlying REST APIs. You can either build, host, and maintain this server 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 Pinpoint to ChatGPT or explore our broader architectural overview on connecting Pinpoint to AI Agents.

Giving a Large Language Model (LLM) read and write access to a complex Applicant Tracking System (ATS) like Pinpoint—similar to how teams connect Ashby or Greenhouse to Claude—introduces immediate engineering challenges. You have to handle OAuth 2.0 or API key token lifecycles, map complex applicant relationships to MCP tool definitions, and handle strict data formatting requirements. Every time Pinpoint updates a core endpoint, you have to rewrite your server schemas, redeploy, and test the changes.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Pinpoint, connect it natively to Claude Desktop, and execute complex hiring workflows using natural language.

The Engineering Reality of the Pinpoint API

A custom MCP server is a self-hosted integration proxy. While the open MCP standard provides a predictable JSON-RPC interface for Claude to discover tools, the reality of implementing it against a vendor specific ATS API is difficult. If you build a custom MCP server for Pinpoint, you own the entire API lifecycle. Here are the specific challenges you will face:

Highly Relational Data Models Pinpoint's architecture relies heavily on nested relationships. A candidate record is rarely useful in isolation. To get a complete picture of an applicant, an LLM often needs to traverse the candidate record, the specific job application record, the job description itself, and associated interview feedback. If you expose raw Pinpoint endpoints to Claude without careful schema curation, the model will struggle to join these foreign keys accurately. Truto addresses this by normalizing query and body schemas into flat namespaces for the LLM, making it easier for Claude to execute multi-step relationship lookups.

Confidential Job Filtering Pinpoint explicitly segregates confidential searches. By default, querying the jobs or applications endpoints excludes confidential records. To access them, the API requires specific query parameters, such as passing confidential into the filter [job_visibility] array. If your MCP server does not explicitly document this requirement in the tool schema, the LLM will hallucinate that executive searches do not exist. Truto handles this by injecting clear parameter descriptions directly from the integration's documentation records into the MCP tool definition.

Handling API Rate Limits Pinpoint enforces strict concurrency and rate limits to protect its multi-tenant infrastructure. If an AI agent attempts to iterate through thousands of historical candidates in a tight loop, Pinpoint will reject the requests with a 429 Too Many Requests error. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors automatically. Instead, when Pinpoint returns a 429, Truto passes that error directly to the caller and normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The LLM or the agent framework is completely responsible for reading these headers and executing its own backoff strategy.

How to Generate a Pinpoint MCP Server with Truto

Truto dynamically generates MCP tools from the Pinpoint integration's resource definitions and human-readable documentation. Tools are not hard-coded; they are assembled at runtime. If an endpoint is documented, it becomes an MCP tool.

You can generate an MCP server URL for Pinpoint in two ways: via the Truto UI or programmatically via the API.

Method 1: Creating the Server via the Truto UI

For internal tooling and manual agent testing, the easiest approach is the UI.

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 by methods (e.g., read-only access) or tags (e.g., only expose "candidates" and "jobs").
5. Copy the generated MCP server URL. It will look like https://api.truto.one/mcp/a1b2c3d4e5...

Method 2: Creating the Server via the API

If you are building a B2B SaaS application and want to automatically provision MCP servers for your end-users' connected Pinpoint accounts, you can use the REST API.

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

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

The response contains the secure URL you will provide to your MCP client.

How to Connect the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude requires zero additional code. The URL contains a cryptographic token that dictates exactly which Pinpoint account to query and which tools to expose. You can configure this via the UI or manually via a configuration file.

Method 1: Via the Claude UI

If you are using Claude Desktop or an enterprise workspace with UI configuration enabled:

1. Open Claude and navigate to Settings -> Integrations.
2. Click Add MCP Server (or Custom Connector, depending on your version).
3. Paste the Truto MCP URL into the Server URL field.
4. Click Add.

Claude will immediately execute the JSON-RPC handshake, requesting the tools/list endpoint to discover all available Pinpoint operations.

Method 2: Via Manual Configuration File

If you are managing Claude Desktop configurations directly for developers or using an open-source MCP inspector, you can add the server to your claude_desktop_config.json file. Truto exposes the MCP protocol natively over HTTPS POST, but for clients that expect standard stdio server execution, you can use the official SSE transport bridge.

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

Restart Claude Desktop. The prompt bar will now show an integration icon confirming that the Pinpoint tools are loaded and ready.

Hero Tools for Pinpoint

Truto automatically maps Pinpoint's REST endpoints into descriptive, snake_case tools. The query parameters and request bodies share a flat input namespace, which Truto handles dynamically.

Here are the most critical tools for automating recruiting workflows.

list_all_pinpoint_jobs

This tool retrieves all active job postings. It is the starting point for any workflow that needs to identify open headcounts or extract job descriptions. By default, confidential jobs are excluded.

Usage Note: If the agent needs to search for an executive role, explicitly instruct it to pass confidential in the filter [job_visibility] array.

"Find all open engineering roles in Pinpoint. Make sure to include confidential searches in the query. Return the job titles, compensation details, and their respective job IDs."

list_all_pinpoint_candidates

This tool queries the candidate database. It returns high-level demographic data, contact information, and IDs. Because ATS databases are massive, this endpoint is paginated using limit and next_cursor.

Usage Note: Truto explicitly injects instructions into the tool schema telling Claude to pass the next_cursor value back unmodified when paginating.

"Search our candidate pool for anyone named 'Alex'. Retrieve the first 50 results and give me their full names, email addresses, and candidate IDs."

get_single_pinpoint_candidate_by_id

Once a candidate is identified, this tool retrieves their comprehensive profile, including deeply nested relationships like their active applications, answers to screening questions, and custom attributes. This process of deep context retrieval is similar to what's possible when you connect BambooHR to Claude for full applicant histories.

Usage Note: This tool requires a valid candidate id. It is almost always used in sequence immediately following a list query.

"Get the full profile for candidate ID 98765. Summarize their address, phone number, and list the IDs of any applications they currently have open."

list_all_pinpoint_applications

Applications are the connective tissue in Pinpoint - they link a specific candidate to a specific job and track their progress through hiring stages.

Usage Note: You can filter this list by candidate_id or job_id to narrow down the results. The response will include the stage_id denoting where the candidate is in the pipeline.

"List all active applications for the Senior Backend Developer job (ID 1234). Group them by their current stage ID and extract the candidate IDs for each."

create_a_pinpoint_comment

This tool allows the agent to write feedback directly to an entity in Pinpoint, such as logging an interview summary on a candidate's application.

Usage Note: You must provide the body_text and correctly map the polymorphic commentable relationship (e.g., specifying whether you are commenting on an application or a job seeker).

"Add a private comment to application ID 5566 stating: 'Candidate passed the technical screen with flying colors. Recommended for final round.'"

update_a_pinpoint_candidate_by_id

This tool modifies an existing candidate record. It is particularly useful for enriching profiles, updating contact information, or logging structured custom attributes discovered during an interview.

Usage Note: Pinpoint separates standard fields from custom_attributes. To update custom fields, the agent must pass the exact attribute format expected by the API.

"Update the candidate profile for ID 98765. Add a note to their summary mentioning their preferred timezone is EST, and ensure their locale is set correctly."

For the complete tool inventory and granular schema definitions, refer to the Pinpoint integration page.

Workflows in Action

MCP servers transform LLMs from passive text generators into active operational agents. When Claude has access to the Pinpoint tools, it orchestrates complex API sequences autonomously. Here are two real-world recruiting scenarios.

Scenario 1: Automated Interview Prep Briefing

Recruiters spend hours compiling notes before an interview. An AI agent can pull this context in seconds.

"I have an interview with Sarah Jenkins for the Product Manager role tomorrow. Please find her profile in Pinpoint, pull her specific application for that job, and write a concise briefing covering her background, how long she has been in the pipeline, and any previous feedback left by other interviewers."

Execution Sequence:

1. The agent calls list_all_pinpoint_candidates with a search filter for "Sarah Jenkins" to extract her id.
2. The agent calls list_all_pinpoint_applications filtered by her candidate_id to find the PM application.
3. The agent calls get_single_pinpoint_job_by_id using the job ID from the application to understand the role's responsibilities.
4. The agent calls list_all_pinpoint_comments filtering for her application ID to retrieve historical interviewer notes.
5. Claude synthesizes the payloads and outputs a clean, markdown-formatted briefing document.

Scenario 2: Bulk Disposition and Feedback

Closing out rejected candidates manually is a tedious administrative task. AI agents can automate the data entry.

"We just filled the Junior Analyst role (ID 8899). Find all other candidates who currently have active applications for this job. Add a comment to their applications saying 'Role filled internally, keep on file for future ops', and let me know how many records were updated."

Execution Sequence:

1. The agent calls list_all_pinpoint_applications with a filter for job_id: 8899 and an active status.
2. Claude extracts the list of application IDs from the response array.
3. The agent enters a loop, calling create_a_pinpoint_comment for each extracted application ID, passing the requested string as the body_text.
4. Claude returns a summary report to the user confirming the exact IDs that were processed.

Security and Access Control

Exposing an ATS to an LLM requires strict governance. If an agent goes rogue, you do not want it deleting candidates or altering historical hiring data. Truto's MCP architecture provides native security constraints built directly into the token layer:

• Method Filtering: You can enforce immutability by setting config.methods: ["read"]. The MCP server will completely drop tool generation for create, update, and delete endpoints. Claude physically will not know those tools exist.
• Tag Filtering: You can restrict the server's scope to specific functional areas using config.tags. For example, setting tags to ["jobs", "departments"] prevents the agent from interacting with candidate PII or sensitive compensation data.
• Require API Token Auth: By default, possession of the Truto MCP URL grants access. For enterprise deployments, you can set require_api_token_auth: true. This forces the MCP client to pass a valid user session or Bearer token, adding an identity verification layer to every tool execution.
• Ephemeral Servers: You can set an expires_at datetime when creating the server. Truto uses distributed key-value expiration and scheduled cleanup alarms to physically purge the token from the database, ensuring short-lived agent sessions cannot be abused later.

Next Steps for AI-Driven Recruiting

Connecting Pinpoint to Claude via a managed MCP server removes the heavy lifting of API maintenance. Instead of writing custom pagination logic, managing OAuth state, or parsing complex JSON:API relationships, your engineering team can focus on designing the actual agentic workflows.

By leveraging Truto's dynamic tool generation, your AI agents always have access to the most up-to-date representation of your Pinpoint workspace. When Pinpoint adds a new resource, Truto updates the documentation, and the MCP tool automatically appears in Claude's context window without a single code deployment.