Connect RocketReach to Claude: Lookup Company Data and Verify Emails

If your team uses ChatGPT, check out our guide on connecting RocketReach to ChatGPT or explore our broader architectural overview on connecting RocketReach to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling B2B data provider like RocketReach is an engineering challenge. You have to handle API key lifecycles, map massive JSON schema definitions to MCP tool definitions, and deal with RocketReach's strict rate limits and complex asynchronous enrichment patterns. Every time RocketReach updates an endpoint or deprecates a search parameter, 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 Model Context Protocol (MCP) server for RocketReach, connect it natively to Claude, and execute complex lead generation and data enrichment workflows using natural language.

The Engineering Reality of the RocketReach 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 a highly specialized B2B data platform is painful.

If you decide to build a custom MCP server for RocketReach, here are the specific integration challenges you will face:

The 10,000 Record Pagination Wall

RocketReach possesses a database of over 700 million professionals. However, its API architecture enforces a strict hard stop on pagination: you cannot fetch results past the 10,000th record (start=10000). If an LLM issues a broad query (e.g., "Find all software engineers in the United States"), the API will eventually throw an error when the agent attempts to paginate past that ceiling. Truto's integration layer passes the pagination cursors cleanly to the model, but you must architect your agent's system prompts to narrow down filters (by city, specific employer, or niche titles) to ensure total result sets fall under the limit.

Asynchronous Enrichment and Polling

When you request to enrich a person's profile to reveal verified contact data, the result is rarely synchronous. RocketReach often places these lookups into a queue. The API returns an initial response with a status of searching or waiting. An LLM naturally expects a synchronous answer. Your MCP server must expose specific status-checking tools (like rocket_reach_people_check_status) and instruct the LLM to cache the profile IDs and poll the endpoint until the status flips to complete. Building this state machine into an LLM toolset requires careful schema descriptions.

Segmented Credit Architectures

RocketReach strictly segments its endpoints based on your billing plan - specifically delineating between "Export" credits and "Universal" credits. If an LLM accidentally calls a Universal lookup endpoint while authenticated on an Essentials plan, the API throws a hard 403 Forbidden error. A managed MCP server allows you to filter out incompatible endpoints at the server generation level, ensuring Claude never hallucinates tool calls that your billing plan cannot support.

Rate Limits and 429s

When hitting RocketReach's search endpoints, rate limit exhaustion is a real threat, especially with an autonomous agent looping through lists. Truto does not retry, throttle, or apply backoff on rate limit errors. When RocketReach returns an HTTP 429, Truto passes that error directly back to the caller. However, Truto does normalize the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your MCP client or agent framework is entirely responsible for reading these headers, pausing execution, and applying exponential backoff.

Generating the RocketReach MCP Server

Instead of building a proxy layer from scratch, you can use Truto to dynamically generate a secure MCP server URL. Truto derives the tool definitions directly from its unified schema registry, meaning the LLM gets perfectly formatted JSON schemas for every RocketReach endpoint.

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

Method 1: Via the Truto UI

If you are setting up an environment for internal operations, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected RocketReach account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can filter the tools to only expose read operations or specific tags (e.g., limiting the server to only "Company Search" tools).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/abc123xyz).

Method 2: Via the API

If you are deploying AI agents programmatically or provisioning infrastructure as code, use the Truto REST API to generate the server URL dynamically.

Make a POST request to /integrated-account/:id/mcp with your authentication token.

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": "Claude Desktop RocketReach Server",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The API provisions a cryptographically secure token stored in distributed key-value storage and returns the ready-to-use URL:

{
  "id": "mcp-789",
  "name": "Claude Desktop RocketReach Server",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/abc123xyz"
}

This URL is completely self-contained. It encodes the tenant mapping, the authentication state, and the allowed tools.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can connect it to your AI environment. Here are the two primary methods for integrating with Claude.

Method A: Via the Claude UI (Enterprise / Web)

If you are using Claude's web interface (or an equivalent setup in ChatGPT):

1. Open Settings -> Integrations -> Add MCP Server (in ChatGPT, this is under Settings -> Connectors -> Add).
2. Paste your Truto MCP URL.
3. Click Add.

Claude will immediately execute the JSON-RPC handshake (initialize and tools/list) and surface the available RocketReach tools in its context window.

Method B: Via Manual Config File (Claude Desktop)

If you are running Claude Desktop locally for development, you must map the URL in your configuration file. Open your claude_desktop_config.json file (typically found in ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows) and add an SSE transport configuration.

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

Restart Claude Desktop. The application will boot the SSE client, connect to the Truto edge router, and load your RocketReach integration.

Hero Tools for RocketReach

RocketReach exposes dozens of specific operations. Truto translates these into explicitly defined tools with rigid query and body schemas, allowing Claude to execute complex data operations without guessing the payload structure.

Here are the critical tools for executing high-value data enrichment workflows.

list_all_rocket_reach_search_people

This is the core discovery engine. It searches RocketReach's 700M+ professional profiles by name, keyword, current title, employer, and location. It returns a list of profiles including name, title, and a teaser of contact data. Because it triggers the 10k pagination limit, instruct Claude to use highly specific query parameters.

"Search RocketReach for people currently holding the title of 'Chief Information Security Officer' at companies located in 'Austin, Texas'. Return the first 50 results with their profile IDs."

rocket_reach_people_lookup

Takes an identifier (typically the profile id from a search, but it accepts LinkedIn URLs or emails) and executes an enrichment call. This tool consumes export credits and returns the full profile. Because it can be asynchronous, Claude must check the status field in the response.

"Take the profile ID '12345678' and run a full people lookup to get their verified email addresses. If the status returns as 'searching', let me know."

list_all_rocket_reach_search_companies

Searches the company database by name, domain, industry, geo, employee count, and revenue. It is highly useful for building target account lists before executing people searches.

"Find companies in the 'Financial Services' industry located in the United Kingdom with revenue between $10M and $50M. Give me their names, domains, and RocketReach IDs."

rocket_reach_companies_lookup

Enriches a single company by domain, ID, or ticker symbol. It returns exhaustive firmographic data, including tech stack, department breakdowns, and growth signals.

"Run a company lookup on the domain 'acmecorp.com'. I need to see their estimated employee count, total revenue, and a list of the technologies in their current tech stack."

rocket_reach_people_check_status

A critical tool for managing asynchronous lookups. It accepts an array of profile IDs and returns their current enrichment state (complete, failed, waiting, searching, or progress). Once complete, the contact info is populated.

"Check the status of the following RocketReach profile IDs: '111', '222', and '333'. If any of them are marked as 'complete', print out their recommended professional emails."

create_a_rocket_reach_email_verification

Verifies whether a specific email address can actively receive mail by performing an MX record check and SMTP handshake. It charges one verification credit, which is refunded if the result is unknown or improperly formatted.

"Run an email verification check on 'j.doe@example.com'. Return the verification status and the detailed SMTP checks from the response."

For the complete tool inventory, including Universal Credit endpoints and bulk lookup tools, check out the Truto RocketReach integration page.

Workflows in Action

By chaining these tools together, Claude transforms from a chatbot into an autonomous data operations engineer.

Scenario 1: Automated Target Account Penetration

Persona: Sales Operations Engineer

"We need to build a pipeline for mid-market logistics companies in California. First, search for companies in the logistics industry based in California with 50-200 employees. Take the top 3 results, and run a people search for anyone with the title 'VP of Operations' at those specific companies. Finally, run a profile lookup on those individuals to get their verified emails."

Execution Steps:

1. Claude calls list_all_rocket_reach_search_companies using filters for industry: logistics, location: California, and employees: 50-200.
2. Claude extracts the company names and IDs from the JSON response.
3. Claude loops through list_all_rocket_reach_search_people, passing current_title: VP of Operations and the respective employer names.
4. Claude collects the resulting profile IDs and calls rocket_reach_people_lookup to consume credits and pull the verified contact data, presenting a clean list to the user.

sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Router
    participant Upstream as RocketReach API

    User->>Claude: "Find California logistics companies..."
    Claude->>Truto: Call list_all_rocket_reach_search_companies<br>(location=CA, size=50-200)
    Truto->>Upstream: GET /api/v2/search/companies
    Upstream-->>Truto: Return company array
    Truto-->>Claude: JSON subset (names, ids)
    
    loop For top 3 companies
        Claude->>Truto: Call list_all_rocket_reach_search_people<br>(employer=name, title="VP Operations")
        Truto->>Upstream: GET /api/v2/search/people
        Upstream-->>Truto: Return people teasers
        Truto-->>Claude: Profile IDs
    end

    Claude->>Truto: Call rocket_reach_people_lookup (ids)
    Truto->>Upstream: GET /api/v2/lookupProfile
    Upstream-->>Truto: Return verified emails
    Truto-->>Claude: Final contact data
    Claude-->>User: Present enriched lead list

Scenario 2: List Cleansing and Verification

Persona: RevOps Administrator

"I have a list of three emails that hard-bounced yesterday: 'sarah@demo1.com', 'mike@demo2.com', and 'alex@demo3.com'. Run an email verification on all three to confirm their status. If any return as invalid, try to find the actual person on RocketReach by their first name and domain, and run a lookup to get their updated email."

Execution Steps:

1. Claude calls create_a_rocket_reach_email_verification sequentially for the three provided emails.
2. Claude analyzes the status and checks object in the response. It identifies that mike@demo2.com is permanently invalid.
3. Claude parses the invalid address into a name ("Mike") and employer domain ("demo2.com").
4. Claude calls list_all_rocket_reach_search_people with name: Mike and employer: demo2.com.
5. Claude grabs the resulting profile ID and calls rocket_reach_people_lookup to retrieve Mike's new, valid email address from his current employer.

Security and Access Control

Exposing an expensive, credit-based data platform like RocketReach to an autonomous AI requires strict guardrails. Truto's MCP architecture provides several layers of access control built directly into the server token:

• Method Filtering: Restrict the MCP server to only allow specific operations. You can configure methods: ["read"] to allow searching without allowing the AI to consume export credits via lookup.
• Tag Filtering: Scope the available tools to specific domains. For example, applying tags: ["companies"] ensures the agent can only research firmographic data and cannot access personal contact info.
• Require API Token Auth: By setting require_api_token_auth: true, possession of the MCP URL is no longer sufficient. The client must also pass a valid Truto API token in the Authorization header to execute tools.
• Time-to-Live (TTL): You can set an expires_at timestamp. Once the server expires, cloud infrastructure automatically deletes the token and the cleanup alarm purges the configuration, instantly severing the LLM's access to RocketReach.

Wrapping Up

Connecting Claude to RocketReach opens up incredibly powerful, autonomous data workflows for your sales and RevOps teams. However, writing custom integration code to handle 10k pagination walls, async polling loops, and strict 429 rate limit headers is a waste of engineering time.

By deploying a managed MCP server via Truto, you abstract away the API mechanics and provide Claude with clean, documented JSON schemas. Your agents can immediately start searching, enriching, and verifying data, while your engineering team maintains complete control over authentication, rate limit headers, and credit consumption.