Connect SpringVerify US to Claude: Manage Screening and Webhooks

If you need to connect SpringVerify US to Claude to automate background screening, manage candidate pipelines, or configure HR webhooks, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM tool calls and SpringVerify'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 SpringVerify US to ChatGPT or explore our broader architectural overview on connecting SpringVerify US to AI Agents.

Giving a Large Language Model (LLM) read and write access to a compliance-heavy platform like SpringVerify US is an engineering challenge. You are dealing with Personally Identifiable Information (PII), asynchronous background check states, and binary report payloads. Every time SpringVerify 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 SpringVerify US, connect it natively to Claude, and execute complex screening workflows using natural language.

The Engineering Reality of the SpringVerify US 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 specific vendor APIs is painful.

If you decide to build a custom MCP server for SpringVerify US, you own the entire API lifecycle. Here are the specific challenges you will face with this particular platform:

Asynchronous State Machines Background checks are not instant. When you create a candidate in SpringVerify US, the screening process can take days. If an LLM is tasked with "getting the background check result for John Doe," a naive implementation will cause the model to poll the API endlessly, hallucinate a final state, or get stuck in a loop. A proper MCP implementation must expose webhooks as first-class tools, enabling the LLM to register a destination for async updates rather than brute-force polling.

Handling Binary PDF Reports SpringVerify US provides finalized screening reports as PDFs. Exposing an endpoint that returns a raw application/pdf binary stream directly to Claude will crash the context window or result in garbage text generation. Truto proxies these requests, allowing the agent to generate download URLs or pass the binary stream to a specialized OCR tool downstream, rather than attempting to parse the byte array natively.

Multi-Tenant Company Contexts Many organizations using SpringVerify operate as agencies managing multiple sub-companies. API requests often require specific company ID headers or routing logic depending on the context. Truto maps these endpoints dynamically, providing Claude with structured query schemas that enforce necessary ID parameters, preventing the model from executing checks in the wrong tenant environment.

How to Generate a SpringVerify US MCP Server with Truto

Truto dynamically derives tool definitions directly from the integration's documented API schemas. When you create an MCP server, Truto packages these endpoints into an authenticated, standardized JSON-RPC interface.

You can generate the MCP server using either the Truto UI or the API.

Method 1: Via the Truto UI

For teams who want to generate a connection manually:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected SpringVerify US instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (name, allowed methods, tags, and expiry).
5. Click Create and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/abc123def...).

Method 2: Via the Truto API

For developers who need to generate the MCP server programmatically when automating infrastructure or building multi-tenant AI agents, Truto checks the API schema, generates a secure cryptographically hashed token, and provisions the server in milliseconds.

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

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "SpringVerify US Screening Agent",
    "config": {
      "methods": ["read", "write"]
    }
  }'

The response returns a fully provisioned URL:

{
  "id": "mcp_srv_98765",
  "name": "SpringVerify US Screening Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, you need to connect it to Claude. The server is completely self-contained - the URL contains the cryptographic token needed to authenticate requests to the specific SpringVerify US account.

You can connect via the Claude UI or via a configuration file for local desktop agents.

Method A: Via the Claude UI

If you are using Claude's web interface (Enterprise/Team plans) or ChatGPT:

1. In Claude, navigate to Settings -> Integrations -> Add MCP Server (in ChatGPT, this is under Settings -> Connectors -> Add).
2. Name the integration "SpringVerify US".
3. Paste the Truto MCP URL.
4. Click Add.

Claude will immediately call the tools/list protocol method to discover all available SpringVerify operations.

Method B: Via Manual Config File

If you are using Claude Desktop or a custom LangChain/Cursor agent, you can mount the MCP server using Server-Sent Events (SSE) via the official Node wrapper. Open your claude_desktop_config.json file and add:

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

Restart Claude Desktop. The agent will read the config and initialize the JSON-RPC handshake.

SpringVerify US Hero Tools

When Claude connects to the Truto MCP server, it receives a flattened list of tools. Below are the highest-leverage operations for SpringVerify US.

create_a_spring_verify_us_candidate

This tool initiates a new background verification case by creating or inviting a candidate. The agent must pass the candidate's basic details and the specific screening package required.

Usage note: SpringVerify relies heavily on email invitations for candidates to submit their own PII securely. Ensure your prompt provides an email address.

"Create a new candidate in SpringVerify US for Alex Mercer (alex.mercer@example.com). Send them an invite for the standard criminal background check package."

get_single_spring_verify_us_candidate_by_id

Retrieves the current status, timeline, and associated data for a specific background verification case.

Usage note: Because background checks are asynchronous, an agent will use this tool to audit a candidate's progress through the verification pipeline.

"Check the status of the background verification for candidate ID 'cand_84729'. Summarize any pending actions required by the candidate."

spring_verify_us_candidates_report

Downloads the finalized PDF report for a background verification case through the proxy API.

Usage note: This tool returns a file payload. Instruct Claude to generate a secure download link or pass the file reference to a workspace tool (like Google Drive) rather than asking it to read the binary directly.

"The screening for candidate 'cand_84729' is complete. Fetch the candidate report PDF and prepare an email draft to the HR team with the file link."

list_all_spring_verify_us_webhooks

Lists all webhook endpoints configured for the company.

Usage note: Crucial for auditing IT configurations to ensure that background check completion events are being routed to your internal ATS or HRIS.

"List all active SpringVerify US webhooks. Check if there is an endpoint currently listening for the 'candidate.report.completed' event."

create_a_spring_verify_us_webhook

Registers a new webhook endpoint to listen for specific SpringVerify US events.

Usage note: Use this tool to establish async event pipelines rather than relying on the LLM to poll candidate statuses endlessly.

"Create a new SpringVerify US webhook pointing to 'https://api.ourcompany.com/webhooks/springverify'. Configure it to trigger on candidate status changes and report completions."

list_all_spring_verify_us_company

Retrieves the company records and sub-tenant accounts visible to the authenticated user.

Usage note: Essential for agencies or enterprises managing multiple distinct legal entities. The agent can use this to map company IDs before creating new candidates.

"List all SpringVerify US company records under our master account. Find the company ID for our EMEA subsidiary."

For the complete tool inventory and detailed schema definitions, visit the SpringVerify US integration page.

Workflows in Action

Exposing individual tools is helpful, but the real power of connecting SpringVerify US to Claude lies in multi-step orchestration. Here is how agents execute complex operations in the real world.

Workflow 1: The Automated HR Screening Kickoff

IT and HR Operations teams spend hours manually initiating background checks when candidates accept an offer in the ATS. Claude can automate this entirely.

"We just hired Sarah Jenkins. Create a new candidate profile for her in SpringVerify US using sarah.j@example.com. Then, check our active webhooks to ensure our ATS is registered to receive status updates. If no webhook exists for our ATS, create one."

Step-by-step execution:

1. Claude calls create_a_spring_verify_us_candidate with Sarah's details to trigger the invite.
2. Claude calls list_all_spring_verify_us_webhooks and parses the response to look for the ATS URL.
3. If missing, Claude calls create_a_spring_verify_us_webhook to establish the connection.

Result: The LLM independently initiates the check and verifies the infrastructure required to update the ATS asynchronously, confirming both actions back to the user.

Workflow 2: Compliance Auditing and Report Retrieval

Compliance officers often need to audit specific cases and pull final documentation for employee files.

"Find the SpringVerify US candidate profile for ID 'cand_99210'. If their status is marked as 'cleared', pull the finalized report PDF."

Step-by-step execution:

1. Claude calls get_single_spring_verify_us_candidate_by_id passing 'cand_99210'.
2. The model evaluates the returned JSON schema. It identifies status: cleared.
3. Claude calls spring_verify_us_candidates_report to retrieve the finalized PDF payload.

Result: The agent validates the business logic (is the candidate actually cleared?) before attempting to retrieve the sensitive document.

Security and Access Control

Granting an AI agent access to an HR compliance system requires strict governance. Truto provides several mechanisms to lock down the MCP server at creation time:

• Method Filtering: By passing methods: ["read"] in the configuration, you can restrict the server to only get and list operations. Claude will be able to audit candidates and webhooks but will physically lack the tools to create new candidates or modify settings.
• Tag Filtering: You can restrict the MCP server to specific functional areas using tags. For example, exposing only webhook management tools to an IT ops agent, while keeping candidate data hidden.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting this flag to true, the MCP client must also provide a valid Truto API token in the Authorization header, enforcing a dual-layer security model.
• Temporary Access (expires_at): You can set an ISO datetime for expires_at. Once the timestamp is reached, Truto automatically schedules a cleanup alarm and destroys the server. This is perfect for giving a contractor or short-lived agent temporary auditing access.

Handling Rate Limits and Errors

It is critical to understand how API limits work in an AI context. Truto does not retry, throttle, or apply backoff on rate limit errors.

When SpringVerify US rate limits an account, it returns an HTTP 429. Truto intercepts this, normalizes the upstream rate limit information, and passes it back to the Claude client using standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset).

The agent framework (whether it is Claude Desktop, LangGraph, or a custom application) is entirely responsible for reading these headers, waiting for the reset window, and retrying the tool execution. This fail-fast architecture prevents Truto from holding open long-running, blocked connections and gives your engineering team deterministic control over agent backoff logic.

Moving from Manual HR to Agentic Workflows

Connecting SpringVerify US to Claude transforms background screening from a manual, click-heavy process into an automated, conversational workflow. By leveraging a managed MCP server, you abstract away the complexities of OAuth token management, pagination, and schema parsing.

Instead of dedicating sprints to maintaining brittle API connectors, your engineering team can focus on designing the agent prompts and business logic that actually drive value for your HR and compliance teams.