Connect People Data Labs to Claude: Power Person and Company Research

If your team needs to connect People Data Labs to Claude to automate talent sourcing, enrich inbound B2B leads, or conduct complex firmographic research, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and People Data Labs'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 People Data Labs to ChatGPT or explore our broader architectural overview on connecting People Data Labs to AI Agents.

Giving a Large Language Model (LLM) read access to a sprawling identity graph like People Data Labs (PDL) is an engineering challenge. You are not just dealing with simple CRUD APIs. You have to handle complex Elasticsearch and SQL query schemas, manage strict bulk payload limits, and interpret varied 404 responses that signify lack of data rather than routing errors. Every time you want to expose a new slice of PDL's dataset, you have to update your server code, map the new JSON schema to an MCP tool definition, and redeploy.

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

The Engineering Reality of the People Data Labs 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, the reality of implementing it against specialized data enrichment APIs is painful. People Data Labs is built to query billions of records spanning people, companies, and locations. Its API reflects that immense scale and complexity.

If you decide to build a custom People Data Labs MCP server, here are the specific integration challenges you will face:

Complex Query Languages and Strict Schemas PDL's search endpoints (/person/search and /company/search) do not rely on standard URL query parameters. Instead, they require the caller to pass either a raw Elasticsearch query or a SQL string in the request body. If you directly expose these endpoints to Claude without strict JSON Schema definitions, the LLM will hallucinate invalid Elasticsearch syntax or attempt to use unsupported SQL functions. A well-architected MCP layer must provide ironclad tool schemas that constrain the LLM's query generation to PDL's supported dialects.

Credit Consumption and 404 Ambiguity PDL operates on a strict credit model, and the API behaves differently depending on the endpoint. For enrichment APIs, a 200 OK deducts credits, while a 404 Not Found (meaning no match exists) is free. However, for the Identify API, a 404 is still billed as 1 credit. Furthermore, a 404 from PDL typically returns a JSON body like {status: 404, error: {message: "No records found"}} rather than a standard empty result set. If your MCP server does not intercept and normalize these 404s, Claude will interpret the HTTP 404 as an infrastructure failure ("Endpoint not found") rather than a valid business response ("No person matches this email").

Bulk Array Wrapping PDL's bulk enrichment endpoints require an array of up to 100 objects wrapped in a highly specific requests array, where each object contains a nested params property. LLMs notoriously struggle with deeply nested, repeated array structures. Your MCP abstraction layer must carefully map the LLM's flat tool arguments into PDL's expected bulk array format to prevent malformed request errors.

Creating the People Data Labs MCP Server

Truto abstracts away the complexity of the People Data Labs API by dynamically generating MCP tools based on your environment's integration documentation. When you create an MCP server in Truto, you generate an isolated, secure JSON-RPC 2.0 endpoint scoped specifically to your connected PDL account.

You can generate this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your People Data Labs connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure your server by selecting allowed methods (e.g., only read operations) or filtering by specific tags (e.g., enrichment, search).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For teams managing AI infrastructure as code, you can generate MCP servers programmatically. When you make this request, Truto hashes the generated token, provisions distributed edge storage for rapid routing, and schedules durable cleanup jobs if an expiration time is provided.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude PDL Research Agent",
    "config": {
      "methods": ["read", "custom"],
      "tags": ["enrichment"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response returns the secure token URL used to connect Claude:

{
  "id": "mcp_abc123",
  "name": "Claude PDL Research Agent",
  "config": { "methods": ["read", "custom"], "tags": ["enrichment"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to Claude

Once you have your Truto MCP server URL, connecting it to Claude requires no additional authentication or middleware on your end—the URL itself contains the cryptographic token necessary to route requests to your specific PDL account.

Method A: Via the Claude UI

If you are using Claude for Web or Enterprise:

1. In Claude, navigate to Settings → Integrations → Add MCP Server.
2. Paste your Truto MCP server URL into the configuration field.
3. Click Add. Claude will immediately perform a handshake with the Truto JSON-RPC router, fetch the available PDL schemas, and populate the model's context with the new tools.

Method B: Via the Config File (Claude Desktop)

If you are building local workflows with Claude Desktop, you must configure the claude_desktop_config.json file. Because Truto provides a remote SSE (Server-Sent Events) endpoint, you utilize the official @modelcontextprotocol/server-sse transport.

Add the following to your configuration file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

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

Restart Claude Desktop. The MCP router handles the protocol handshake, parsing PDL's documentation records on the fly to derive precise JSON schemas for both query parameters and request bodies, presenting them as a flat argument namespace to the LLM.

Hero Tools for People Data Labs

Truto exposes the entirety of the PDL API as MCP tools. However, for AI agents focused on research and enrichment, a specific subset of endpoints drives the vast majority of business value.

Here are the most powerful tools your Claude agent can now access.

Search People (people_data_labs_people_search)

Executes complex Elasticsearch or SQL queries against PDL's person database. It automatically handles the scroll_token logic, instructing Claude on how to paginate through results. It returns profiles containing current employment, work history, and contact metadata.

"Find software engineers living in San Francisco who currently work at Stripe. Use a SQL query to filter for current_company = 'stripe' and location = 'san francisco'. Fetch the first page."

Bulk Enrich People (people_data_labs_people_bulk_enrich)

Enriches up to 100 people in a single API call, optimizing API round-trips and credit usage. Claude can map raw lists of emails or LinkedIn profile URLs into PDL's required requests array format automatically.

"I have a list of 45 email addresses from yesterday's webinar. Pass them to the bulk enrichment tool to find their current job titles, seniority levels, and company sizes."

Search Companies (people_data_labs_companies_search)

Queries the PDL company dataset using Elasticsearch or SQL. This is the foundation for automated Account-Based Marketing (ABM) list building.

"Run an Elasticsearch query to find B2B SaaS companies headquartered in London with an employee count between 50 and 200. Return their domains and LinkedIn URLs."

Clean Companies (people_data_labs_companies_clean)

Normalizes messy, user-inputted company names or website URLs into structured company records. This tool is heavily utilized for inbound lead routing, converting a raw string like 'Acme Corp LLC' into standard firmographics.

"Take this raw input 'amazon web services' and clean the company record to find its canonical website, industry classification, and global headcount."

Clean Job Titles (people_data_labs_job_titles_enrich)

Standardizes raw job title strings into canonical roles and extracts relevant skill data. Essential for mapping diverse user inputs (e.g., 'Chief Marketing Guru') into structured CRM fields (e.g., 'CMO').

"Clean the job title 'Senior code ninja (backend)' and tell me the normalized job title along with the typical relevant skills associated with it."

Enrich IP Addresses (people_data_labs_ips_enrich)

Maps IPv4 or IPv6 addresses to company data, location details, and metadata. This tool powers anonymous website visitor deanonymization directly inside Claude.

"Analyze this list of 5 IP addresses that visited our pricing page today. Enrich them to tell me which companies they belong to, ignoring any ISP or hosting provider IPs."

For the complete tool inventory and granular schema details, visit the Truto People Data Labs integration page.

Workflows in Action

Connecting PDL to Claude transforms static APIs into autonomous research engines. By combining multiple MCP tools, Claude can execute complex, multi-step data pipelines entirely through natural language.

Workflow 1: Account-Based Marketing (ABM) Lead Sourcing

Sales teams spend hours building targeted lists. With Claude connected to PDL, you can automate account identification and contact sourcing in one prompt.

"Find B2B fintech companies in New York with 50-200 employees. For the top 3 companies you find, search for their VP of Engineering or CTO and provide their names and LinkedIn profiles."

sequenceDiagram
    participant Claude
    participant Truto as Truto MCP
    participant PDL as People Data Labs
    
    Claude->>Truto: Call people_data_labs_companies_search<br>(SQL: industry='fintech' AND location='new york')
    Truto->>PDL: POST /company/search
    PDL-->>Truto: {status: 200, data: [Company A, Company B...]}
    Truto-->>Claude: Returns company domains
    
    Claude->>Truto: Call people_data_labs_people_search<br>(SQL: company IN (...) AND title='CTO')
    Truto->>PDL: POST /person/search
    PDL-->>Truto: {status: 200, data: [Person 1, Person 2...]}
    Truto-->>Claude: Returns enriched person records

1. Claude uses people_data_labs_companies_search to query the PDL database for matching company profiles using SQL.
2. Claude extracts the website or pdl_id of the matching companies from the result.
3. Claude dynamically constructs a new SQL query and calls people_data_labs_people_search to find executive personas tied to those specific companies.
4. Claude synthesizes the data into a clean markdown table of highly targeted prospects.

Workflow 2: Inbound Lead Normalization and Enrichment

When a user submits a minimal form (e.g., just an email and a messy company name), Claude can automatically standardize the data before writing it to your CRM.

"A lead just submitted this data: Name 'J. Doe', Email 'jdoe@acme-global.io', Company 'Acme Global'. Clean the company name to get their true industry, then identify the person using their email to find their actual job title."

sequenceDiagram
    participant Claude
    participant Truto as Truto MCP
    participant PDL as People Data Labs
    
    Claude->>Truto: Call people_data_labs_companies_clean<br>(name: "Acme Global")
    Truto->>PDL: GET /company/clean
    PDL-->>Truto: {status: 200, name: "Acme Corp", industry: "Software"}
    Truto-->>Claude: Returns canonical company data
    
    Claude->>Truto: Call people_data_labs_people_identify<br>(email: "jdoe@acme-global.io")
    Truto->>PDL: GET /person/identify
    PDL-->>Truto: {status: 200, matches: [{data: {...}}]}
    Truto-->>Claude: Returns enriched person data

1. Claude calls people_data_labs_companies_clean with the raw company string, returning structured firmographics (size, industry, canonical domain).
2. Claude uses people_data_labs_people_identify passing the email address to pull the specific user's job title and LinkedIn URL.
3. Claude returns a fully formatted, CRM-ready JSON object combining the cleaned company and enriched person data.

Security and Access Control

Giving an AI agent access to paid enrichment APIs requires strict governance. Truto's MCP architecture provides multiple layers of access control built directly into the server token, ensuring Claude only performs permitted actions.

• Method Filtering: Limit your MCP server to read-only operations by passing "methods": ["read"]. This allows Claude to search and clean data without risking unintended API mutations.
• Tag Filtering: Restrict tools by functional domain. Passing "tags": ["enrichment"] ensures Claude only has access to enrichment endpoints, keeping other internal PDL management APIs hidden.
• Mandatory API Token Auth: For shared environments, enable require_api_token_auth: true. This forces the caller to provide a valid Truto API token in addition to the MCP URL, securing the endpoint against unauthorized network access.
• Automatic Expiration: Provision short-lived agents by setting an expires_at timestamp. Once the timestamp passes, the edge storage records are instantly purged, rendering the MCP URL permanently invalid.

Handling People Data Labs Rate Limits

When building autonomous agents, rate limits are a critical architectural consideration. People Data Labs enforces varied rate limits based on your subscription tier (e.g., 10 calls/min for Identify, 100/min for IP Enrichment).

Truto explicitly does not intercept, retry, or apply exponential backoff to HTTP 429 (Too Many Requests) errors. When PDL rate limits a request, Truto passes the 429 status directly back to the MCP client. However, Truto actively normalizes the upstream rate limit data into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset).

The caller (or the MCP client executing the agent loop) is responsible for reading these normalized headers and implementing its own retry or backoff logic. This pass-through architecture prevents the MCP layer from holding open connections indefinitely or exhausting your edge compute resources during a massive rate limit event.

Moving from Manual Sourcing to Agentic Workflows

Connecting Claude to People Data Labs via an MCP server shifts your operations from manual, script-heavy data pipelines to natural language orchestration. Instead of writing custom Python scripts to paginate through Elasticsearch results, clean messy strings, and bulk enrich lists, your engineers can simply prompt the model to execute the workflow.

By leveraging a managed MCP infrastructure like Truto, you eliminate the integration debt of maintaining JSON schemas, normalizing 404 responses, and wrestling with OAuth or API key lifecycles. Your team focuses purely on designing the optimal prompts for firmographic research, while Truto handles the protocol translation.