---
title: "Connect RocketReach to ChatGPT: Search and Enrich Professional Profiles"
slug: connect-rocketreach-to-chatgpt-search-and-enrich-professional-profiles
date: 2026-10-16
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to connect RocketReach to ChatGPT using an auto-generated MCP server to automate B2B lead enrichment, company research, and email verification."
tldr: "A technical guide to generating a RocketReach MCP server via Truto. Learn how to connect it to ChatGPT, handle RocketReach's credit system and pagination limits, and automate B2B contact enrichment workflows."
canonical: https://truto.one/blog/connect-rocketreach-to-chatgpt-search-and-enrich-professional-profiles/
---

# Connect RocketReach to ChatGPT: Search and Enrich Professional Profiles


If you want to connect RocketReach to ChatGPT to automate B2B lead generation, enrich professional profiles, and execute highly targeted account research, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). If your team uses Claude, check out our guide on [connecting RocketReach to Claude](https://truto.one/connect-rocketreach-to-claude-lookup-company-data-and-verify-emails/) or explore our broader architectural overview on [connecting RocketReach to AI Agents](https://truto.one/connect-rocketreach-to-ai-agents-automate-bulk-lead-discovery/).

Giving a Large Language Model (LLM) autonomous access to a massive, paid data provider like RocketReach presents an immediate engineering challenge. You must translate the LLM's natural language requests into complex JSON query filters, manage pagination limits, and critically, prevent the model from burning through thousands of dollars in API credits due to hallucinated loops. You can either build and maintain this [custom infrastructure yourself](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

This guide breaks down exactly how to use Truto to generate a secure MCP server for RocketReach, connect it natively to ChatGPT, and execute complex prospecting workflows using natural language.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the RocketReach API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against the RocketReach API reveals several specific architectural quirks. 

If you decide to build a custom MCP server for RocketReach, you own the entire API lifecycle. Here are the specific integration challenges you will face:

### The Complex Credit Economy
Unlike standard B2B SaaS platforms that bill based on API requests, RocketReach operates on a highly specific credit economy. They divide their endpoints into distinct usage tiers: Export Credits, Universal Credits, and Verification Credits. For example, standard people searches are free to query, but looking up the actual contact information costs an export credit. If you have a Universal Credit plan, you must hit entirely different API endpoints (e.g., `/v2/api/universalSearch/people` instead of `/v1/api/search`). An LLM does not inherently understand this economy. If you expose all endpoints without filtering, ChatGPT might default to a Universal endpoint your plan doesn't support, resulting in immediate HTTP 403 Forbidden errors.

### The 10,000 Record Pagination Cap
RocketReach searches span over 700 million profiles, but the API explicitly caps query results at 10,000 records. If you attempt to paginate past an offset (or `start` parameter) of 10,000, the API will throw an error. When an LLM executes a broad query like "Find all software engineers in California," the total results will easily exceed this limit. Your MCP server must inject context to instruct the LLM to progressively narrow its filters (adding seniority, specific cities, or exact company names) rather than blindly paginating into the hard limit.

### Asynchronous Bulk Endpoints
For large-scale enrichment, RocketReach relies on asynchronous bulk lookup endpoints. When you submit an array of 100 profile IDs to the bulk endpoint, the API immediately returns a 202 Accepted status with no response body. The actual enriched data is delivered asynchronously to a registered webhook. Standard LLM tool calling is inherently synchronous - the model expects the data back in the tool response. Bridging this gap requires either building a polling loop on the `check_status` endpoint or maintaining an external state store that the LLM can query once the webhook fires.

### Handling Upstream Rate Limits
When an AI agent runs an aggressive automation loop against RocketReach, you will eventually hit concurrency or rate limits. **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the RocketReach API returns an HTTP 429 Too Many Requests, Truto transparently passes that exact error back to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (your agent framework or the end client) is entirely responsible for detecting the 429 and executing the appropriate exponential backoff strategy.

## Creating and Connecting the RocketReach MCP Server

To bridge ChatGPT and RocketReach, we will generate an MCP server via Truto. This server acts as the translation layer, exposing the RocketReach API methods as JSON-RPC 2.0 tools. Truto [derives these tools dynamically](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) from the integration's underlying OpenAPI specification, mapping query parameters and body payloads into precise JSON Schemas.

Each MCP server is scoped to a single integrated account and is accessed via a unique, cryptographically hashed token URL. There are two ways to generate this server.

### Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to **Integrated Accounts**.
2. Click **New Integrated Account**, select RocketReach, and input your API key.
3. Once connected, open the integrated account detail page and click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. You can filter by methods (e.g., read-only) or specific tags to limit the LLM's blast radius.
6. Click save and **copy the generated MCP server URL** (it will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For platform builders provisioning MCP servers programmatically, you can POST to the Truto API. This requires your Truto API token and the `integrated_account_id` of the connected RocketReach account.

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "RocketReach ChatGPT Server",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["people", "companies"]
    }
  }'
```

The API returns a JSON payload containing the `url` field. Treat this URL as a secure credential - it contains the token required to authenticate and execute requests against that specific RocketReach account.

### Connecting the MCP Server to ChatGPT

With your MCP server URL in hand, you can now connect it to ChatGPT. There are two primary deployment patterns: using the ChatGPT UI directly, or configuring a local MCP client via a config file.

#### Option A: Via the ChatGPT UI (Custom Connectors)

If you are on a ChatGPT Pro, Plus, Business, Enterprise, or Education plan, you can add the server directly through the application interface.

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Toggle **Developer mode** on (this enables MCP support).
3. Under the custom connectors section, click **Add new server**.
4. Give the connector a name (e.g., "RocketReach by Truto").
5. Paste your Truto MCP server URL into the Server URL field and click **Save**.

ChatGPT will immediately ping the endpoint, execute the `tools/list` handshake, and register the available RocketReach tools.

#### Option B: Via Manual Config File (Local Desktop)

If you are running a custom desktop agent, an open-source MCP client, or Claude Desktop, you map the remote Truto server using Server-Sent Events (SSE).

Add the following block to your `mcp_config.json` (or `claude_desktop_config.json`):

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

Restart your client, and the tools will be instantly available in the prompt context window.

## RocketReach Hero Tools for AI Agents

When Truto generates the MCP server, it parses the RocketReach integration and exposes operations as snake_case tools. To prevent overwhelming the model, we strongly recommend filtering your MCP server to expose only the highest-leverage endpoints. Here are the core hero tools to enable for B2B prospecting.

### list_all_rocket_reach_search_people

This tool allows the LLM to search RocketReach's massive database of 700 million professional profiles. It accepts a complex query object allowing filtering by name, current_title, employer, location, and industry. The results return matching profiles with teasers of contact data, but the emails are masked. You must use `rocket_reach_people_lookup` to spend a credit and unlock the full record. Remember the 10,000 record cap - instruct the LLM to use precise filters.

> "Find 10 software engineering managers currently working at Stripe in San Francisco. Return their profile IDs and current titles. If the search returns more than 10,000 total hits, narrow the search by adding 'senior' to the title query."

### rocket_reach_people_lookup

This is the core enrichment tool. It consumes an export credit to reveal the fully verified contact information for a specific person. You can pass a RocketReach `id` obtained from the search tool, or supply a `linkedin_url`, `email`, or `name` combined with `current_employer`.

> "Take the profile ID you just found for the Senior Engineering Manager at Stripe and run a lookup to extract their recommended professional email address. Check the 'status' field to ensure the lookup is complete."

### list_all_rocket_reach_search_companies

Allows the LLM to query company records by name, domain, industry, geographic location, employee count, or revenue tier. This is critical for Account-Based Marketing (ABM) workflows, allowing the model to build target account lists before searching for specific personnel.

> "Search for B2B SaaS companies based in Austin, Texas with an employee count between 50 and 200. Give me the top 5 results sorted by relevance, including their domains and industry strings."

### rocket_reach_companies_lookup

Enriches a single company record to retrieve comprehensive firmographic data, including tech stack details, departmental breakdowns, and growth signals. It requires at least one identifier, with the company `domain` being the preferred parameter.

> "Run a company lookup on 'vercel.com'. Extract their reported revenue tier, total employee count, and list out any frontend frameworks identified in their tech stack array."

### create_a_rocket_reach_email_verification

This tool allows the LLM to verify if a specific email address is active and capable of receiving mail. It charges one verification credit, which RocketReach refunds if the result is unknown or the email formatting is invalid. It returns the MX record status and SMTP check results.

> "Verify the email address 'j.doe@example.com'. Return the status and let me know if the SMTP check passed. Also confirm how many verification credits were charged for this call."

### rocket_reach_accounts_get_current

An administrative tool that costs zero credits to call. It allows the LLM to check the authenticated account's current credit usage, plan limits, and daily API call limits. This is crucial for agents operating autonomously to ensure they don't exhaust their monthly quota.

> "Check our current RocketReach account status. Tell me our daily API limit, how many API calls we've made today, and our current export credit usage."

For the complete tool inventory, including bulk lookup schemas and Universal Credit endpoints, visit the [RocketReach integration page](https://truto.one/integrations/detail/rocketreach).

## Workflows in Action

Connecting RocketReach to ChatGPT unlocks agentic workflows that traditionally required dedicated engineering teams to wire up ETL pipelines or reverse-ETL syncing. Here is how an LLM handles multi-step prospecting.

### Workflow 1: Targeted Lead Generation & Enrichment

**Persona:** Sales Development Representative (SDR) building an outreach list.

> "Find the VP of Engineering at Vercel. Once you have their profile, unlock their verified professional email. After getting the email, check our remaining export credit balance to ensure we have capacity for more lookups today."

**Step-by-step Execution:**
1. **`list_all_rocket_reach_search_companies`**: The model first queries the company "Vercel" to confirm the exact domain and company ID to ensure accurate filtering.
2. **`list_all_rocket_reach_search_people`**: The model constructs a query object with `current_title: "VP Engineering"` and `employer: "Vercel"`. It retrieves a list of matches and identifies the correct profile ID.
3. **`rocket_reach_people_lookup`**: The model calls the lookup tool, passing the profile ID. This spends the export credit and returns the full profile payload, including the `recommended_professional_email`.
4. **`rocket_reach_accounts_get_current`**: Finally, the model queries the account endpoint and reports the remaining `credit_usage` back to the user.

```mermaid
sequenceDiagram
    participant User as User Prompt
    participant LLM as ChatGPT
    participant MCP as Truto MCP Server
    participant Upstream as RocketReach API

    User->>LLM: "Find VP Engineering at Vercel..."
    LLM->>MCP: Call list_all_rocket_reach_search_companies<br>{"name": "Vercel"}
    MCP->>Upstream: GET /v1/api/search/company
    Upstream-->>MCP: Company Data (domain: vercel.com)
    MCP-->>LLM: Return Company Schema
    
    LLM->>MCP: Call list_all_rocket_reach_search_people<br>{"query": {"employer": ["vercel.com"], "current_title": ["VP Engineering"]}}
    MCP->>Upstream: POST /v1/api/search
    Upstream-->>MCP: Unverified Profile Array (IDs)
    MCP-->>LLM: Return Profile IDs
    
    LLM->>MCP: Call rocket_reach_people_lookup<br>{"id": 123456}
    MCP->>Upstream: GET /v1/api/lookupProfile
    Upstream-->>MCP: Enriched Profile (with emails)
    MCP-->>LLM: Return Verified Email
    
    LLM-->>User: Outputs verified email and credit balance.
```

### Workflow 2: Account-Based Intelligence Gathering

**Persona:** RevOps Analyst building account profiles for the enterprise sales team.

> "I have a target account: 'linear.app'. Run a company lookup to extract their industry and tech stack. Then, search for anyone with 'Director of Product' in their title at this company. Give me a markdown table of the names and IDs, but do not spend credits looking up their emails yet."

**Step-by-step Execution:**
1. **`rocket_reach_companies_lookup`**: The model passes `domain: "linear.app"` to the company lookup tool. It extracts the firmographic data and the technology arrays.
2. **`list_all_rocket_reach_search_people`**: The model searches for people using the employer domain and the specific title filter. Because it was explicitly instructed not to spend credits, it skips the `rocket_reach_people_lookup` step.
3. **Formatting**: The model parses the JSON response from the search tool and formats the unverified teaser data into the requested Markdown table, handing the target list back to the analyst for manual review.

## Security and Access Control

Exposing an expensive data enrichment API to an autonomous agent requires strict governance. Truto provides several mechanisms to lock down your MCP server when creating it via the API:

*   **Method Filtering:** Use the `config.methods` array to restrict the server to `read` operations only. This allows the LLM to search profiles without ever having the ability to call `rocket_reach_people_lookup` and accidentally burn export credits.
*   **Tag Filtering:** Use the `config.tags` array to limit the tools entirely. If you only want the model doing firmographic research, restrict the server to `["companies"]` to completely hide the people search endpoints.
*   **API Token Authentication:** By default, possession of the MCP URL grants access. For production environments, enable `config.require_api_token_auth`. The client must then pass a valid Truto API token in the Authorization header, preventing unauthorized internal usage if the URL leaks in logs.
*   **Expiration:** Set an `expires_at` ISO datetime when generating the server. Truto will automatically destroy the token and flush the credentials from its KV store when the time elapses, perfect for granting temporary sandbox access to contractors testing prompt chains.

## Closing Thoughts on Data Enrichment via MCP

Connecting RocketReach to ChatGPT shifts the paradigm of B2B prospecting. Instead of manually clicking through a web interface or writing brittle Python scripts to chain API calls together, you can orchestrate complex enrichment loops using natural language. 

The difficulty isn't in parsing the JSON - it's in handling the architectural reality of pagination limits, credit tracking, and upstream rate limits. By relying on a dynamically generated MCP server, your engineering team can completely offload the burden of maintaining endpoint mappings and focus strictly on agent logic and prompt engineering.

Stop fighting API schemas. Configure your MCP server, set your tag filters to protect your credit balance, and let your agents handle the heavy lifting of data discovery.