---
title: "Connect ZoomInfo to ChatGPT: Enrich Contact and Company Intent Data"
slug: connect-zoominfo-to-chatgpt-enrich-contact-and-company-intent-data
date: 2026-10-19
author: Roopendra Talekar
categories: ["AI & Agents"]
excerpt: "Learn how to connect ZoomInfo to ChatGPT using a managed MCP server. Enrich contact data, monitor buyer intent, and orchestrate B2B workflows with AI agents."
tldr: "Connect ZoomInfo to ChatGPT in minutes using Truto's managed MCP servers. Automate B2B prospecting, company enrichment, and buyer intent tracking without building custom API infrastructure."
canonical: https://truto.one/blog/connect-zoominfo-to-chatgpt-enrich-contact-and-company-intent-data/
---

# Connect ZoomInfo to ChatGPT: Enrich Contact and Company Intent Data


If you want to connect ZoomInfo to ChatGPT so your AI agents can enrich contact records, monitor buyer intent signals, and map corporate hierarchies dynamically, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as a translation layer between ChatGPT's tool calling capabilities and the ZoomInfo REST API. You can either spend weeks building, hosting, and maintaining a [custom MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) to translate LLM JSON arguments into ZoomInfo's complex enrichment payloads, or you can use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting ZoomInfo to Claude](https://truto.one/connect-zoominfo-to-claude-track-news-scoops-and-company-structures/) or explore our broader architectural overview on [connecting ZoomInfo to AI Agents](https://truto.one/connect-zoominfo-to-ai-agents-automate-prospecting-and-tech-insights/).

Giving a Large Language Model (LLM) access to an enterprise data intelligence platform is a massive engineering challenge. You have to handle rigid credit - based enrichment logic, strict OAuth scopes tied to specific SKUs, and unpredictable pagination paradigms. Every time ZoomInfo updates an API schema or adds a new intent topic parameter, your custom server code must be updated and redeployed. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for ZoomInfo, connect it natively to ChatGPT, and execute complex B2B 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 ZoomInfo API

A custom MCP server is essentially a self-hosted integration middleware. While the open MCP standard provides a predictable way for models to discover tools over JSON-RPC, implementing it against ZoomInfo's highly specific API is exceptionally painful. 

If you decide to build a custom MCP server for ZoomInfo, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with ZoomInfo:

### The Credit Economy vs Rate Limits
ZoomInfo's API is heavily governed by a dual - limit system: Request Limits (how many HTTP calls you can make) and Record Limits (how many credits you consume). For enrichment endpoints, `NO_MATCH` results generally incur no credit cost, but every enriched record counts against your Record Limit. 

Furthermore, [handling HTTP 429 Too Many Requests errors](https://truto.one/how-to-handle-third-party-api-rate-limits-when-an-ai-agent-is-scraping-data/) is critical. **Factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API returns HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller (or your AI agent framework) is fully responsible for implementing retry and backoff logic. 

### Granular OAuth Scopes and SKUs
ZoomInfo does not grant blanket access to its data. Endpoints are strictly gated by both OAuth scopes and purchased SKUs. For example, querying the intent endpoints requires the `api:data:intent` scope on the OAuth app *and* an active Intent SKU on your ZoomInfo account. If either is missing, ZoomInfo returns a 403 error with specific internal codes (`ZI0002` or `ZI0003`). An LLM has no idea how to interpret this unless your MCP server intercepts and translates the error into a helpful context message.

### Asymmetric Pagination Paradigms
ZoomInfo uses different pagination strategies depending on the endpoint. Search endpoints typically use standard offset and limit parameters, maxing out at page 100. Enrichment endpoints, however, return raw arrays (up to 25 items per call) and require explicit `page.number` and `page.size` parameter manipulation. Truto standardizes this for the LLM by automatically injecting `limit` and `next_cursor` properties into list tool schemas, instructing the model to pass cursor values back unchanged to fetch subsequent pages.

## Creating the ZoomInfo MCP Server

Truto dynamically generates MCP tools from an integration's underlying API resources and documentation records. Rather than hand-coding endpoints, Truto maps ZoomInfo's OpenAPI-like definitions into JSON-RPC 2.0 tool definitions. 

You can create a ZoomInfo MCP server in two ways.

### Method 1: Via the Truto UI

For a quick setup without writing code, use the Truto Dashboard:

1. Navigate to the **Integrated Accounts** page and select your connected ZoomInfo account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., name, allowed methods like `read`, and specific tags to scope access).
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<token>`).

### Method 2: Via the API

For programmatic provisioning - such as generating a temporary MCP server for a specific user session - you can create the server via Truto's REST API.

Make a `POST` request to `/integrated-account/:id/mcp`:

```bash
curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ZoomInfo Enrichment Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["enrichment", "intent"]
    }
  }'
```

The response returns a secure `url` payload. This single URL encapsulates both routing and authentication for the specific ZoomInfo integrated account.

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it with your ChatGPT environment. 

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

If you have a ChatGPT Pro, Plus, Business, Enterprise, or Education account with Developer mode enabled:

1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Ensure **Developer mode** is toggled on.
3. Under MCP servers / Custom connectors, click to add a new server.
4. **Name:** Enter a descriptive label (e.g., "ZoomInfo (Truto)").
5. **Server URL:** Paste the URL generated in the previous step.
6. Click **Save**.

ChatGPT will immediately perform an MCP handshake (`initialize`), request the available tool list (`tools/list`), and expose them to your current session.

### Method B: Via Manual Config File (SSE Transport)

If you are running a local agentic setup, using an MCP-compatible framework like Cursor, or using an open-source ChatGPT UI clone, you can connect via a JSON configuration file using the Server-Sent Events (SSE) transport adapter.

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

This configuration instructs the client to wrap the HTTP POST based Truto endpoint in a persistent SSE connection if required by your specific client architecture.

## ZoomInfo Hero Tools for AI Agents

Truto exposes ZoomInfo's API as highly structured MCP tools. Here are 6 high-leverage "hero tools" to power automated prospecting and enrichment workflows.

### zoom_info_companies_enrich
This tool allows the LLM to enrich up to 25 ZoomInfo company records per call. It matches based on `companyId`, `companyWebsite`, or other company attributes. It returns firmographic attributes such as revenue, employee count, and social media URLs based on the requested output fields.

**Usage Note:** A single credit is charged for every enriched company unless the record is already under management. `NO_MATCH` results do not cost credits.

> "Enrich the company with the website 'acme.com' and return their exact employee count, annual revenue, and HQ location."

### zoom_info_contacts_enrich
Allows the agent to enrich ZoomInfo contacts using a specific `personId` or a combination of name and company details. It returns detailed profile data, including job titles and accuracy scores.

**Usage Note:** Every enriched record counts against the organization's Record Limit.

> "I have a prospect named Jane Doe who works at Acme Corp. Use the contacts enrich tool to pull her verified title and contact accuracy score."

### list_all_zoom_info_intents
Searches ZoomInfo Intent Signals across all companies that match given search criteria. You must pass 1-50 intent topics in the `data.attributes.topics` array. 

**Usage Note:** This tool requires the `api:data:intent` OAuth scope and an active Intent SKU. It does not consume credits, but each signal counts as a Record.

> "Search for companies showing high intent signals for the topic 'Cloud Infrastructure Security' over the past 7 days."

### zoom_info_intents_enrich
Fetches deeply detailed Intent Signals for a single company, enriching it with buyer intent data including `signalScore`, `audienceStrength`, and `recommendedContacts`.

**Usage Note:** You must pass the topics array and at least one company identifier (like `companyWebsite`).

> "Enrich intent data for acme.com on the topics 'Zero Trust' and 'Endpoint Security' and list the recommended contacts to reach out to."

### zoom_info_org_charts_enrich
Enriches a ZoomInfo company's organizational chart, returning contacts organized by specific departments and seniority tiers. 

**Usage Note:** You must pass the `companyId` and at least one `department`. A credit is counted for the enriched company, but you get all the contacts in that department for that single record charge.

> "Pull the org chart for Acme Corp's IT and Engineering departments, filtering for Director-level and above."

### zoom_info_company_technologies_enrich
Enriches technologies for a matched ZoomInfo company, returning the list of software and hardware solutions that the company uses, identified from job postings, websites, and data partnerships.

**Usage Note:** Requires the `api:data:company` OAuth scope. Takes a single `companyId` as input.

> "Find out if Acme Corp currently uses AWS, Datadog, or Snowflake in their technology stack."

To view the complete JSON schema definitions, required parameters, and the rest of the available endpoints, visit the full [ZoomInfo integration page](https://truto.one/integrations/detail/zoominfo).

## Workflows in Action

When connected via Truto, ChatGPT can orchestrate multi-step data pipelines autonomously. Here is how specific personas leverage the ZoomInfo MCP server.

### Scenario 1: ABM Intent & Tech Stack Profiling
**Persona:** Enterprise SDR or Growth Marketer

> "Find companies currently surging on the intent topic 'Data Loss Prevention'. Pick the highest scoring company, check their technology stack to see if they use our competitor (Symantec), and if so, give me a summary of their profile."

**Tool Flow:**
1. **`list_all_zoom_info_intents`**: ChatGPT queries the intent topic "Data Loss Prevention" and receives a list of surging companies.
2. **`zoom_info_companies_enrich`**: The LLM extracts the `companyId` of the top-scoring result and fetches its full firmographic profile.
3. **`zoom_info_company_technologies_enrich`**: The agent uses the `companyId` to pull the tech stack, scanning the results for "Symantec".

**Result:** The user receives a curated target account briefing: "Acme Corp is surging on DLP with a signal score of 95. They have 5,000 employees, $1B in revenue, and currently use Symantec in their tech stack. They are a prime target for a displacement campaign."

```mermaid
sequenceDiagram
    participant User as User Prompt
    participant LLM as ChatGPT
    participant MCP as Truto MCP Server
    participant ZI as ZoomInfo API

    User->>LLM: "Find DLP intent, check tech stack for Symantec"
    LLM->>MCP: Call list_all_zoom_info_intents(topic="DLP")
    MCP->>ZI: GET /intent/search
    ZI-->>MCP: Returns companies (Acme Corp)
    MCP-->>LLM: MCP Tool Response
    LLM->>MCP: Call zoom_info_company_technologies_enrich(companyId)
    MCP->>ZI: POST /enrich/techtags
    ZI-->>MCP: Returns tech stack array
    MCP-->>LLM: MCP Tool Response
    LLM-->>User: Generated ABM Briefing
```

### Scenario 2: Strategic Account Org Chart Mapping
**Persona:** Account Executive

> "I'm trying to break into Globex Corporation. Get their ZoomInfo ID, pull the org chart for their Information Technology department, and identify the top 3 senior decision makers."

**Tool Flow:**
1. **`zoom_info_companies_enrich`**: The LLM searches by domain (`globex.com`) to reliably acquire the ZoomInfo `companyId`.
2. **`zoom_info_org_charts_enrich`**: The agent passes the `companyId` and `department: ["Information Technology"]` to pull the org structure.
3. **LLM Synthesis**: ChatGPT parses the `orgChartTier` fields in the response to filter out individual contributors and bubble up the CIO, VP of IT, and Director of Infrastructure.

**Result:** The AE gets exactly what they asked for - a targeted hit list of verified IT decision makers at Globex, bypassing the need to click through multiple pages of standard contact searches in the ZoomInfo web app.

## Security and Access Control

Giving an LLM access to your ZoomInfo credit pool requires strict governance. Truto MCP servers provide multiple layers of [access control](https://truto.one/mcp-server-security-zero-data-retention-2026-implementation-guide/):

*   **Method Filtering:** Configure the server config with `"methods": ["read"]` to allow the LLM to search for data, but prevent it from executing write/update operations on integrated systems.
*   **Tag Filtering:** Group specific integration resources (like `companies`, `contacts`, `intents`) under tags. You can scope an MCP server to only allow access to `"tags": ["enrichment"]`, hiding all other endpoints from the LLM.
*   **API Token Authentication:** By setting `require_api_token_auth: true`, the bare MCP URL is no longer sufficient. The client must also pass a valid Truto API token in the `Authorization` header, preventing unauthorized usage if the URL is leaked.
*   **Time-to-Live (TTL):** Set an `expires_at` ISO datetime when creating the server. Truto's edge storage automatically purges the authentication token and schedules a cleanup alarm for the database record once the time expires, perfect for temporary agent sessions.

## Conclusion

Connecting ZoomInfo to ChatGPT via a custom MCP server requires parsing deeply nested schemas, managing rate limits without native backoff, and translating complex pagination parameters. 

By using Truto, you offload the entire infrastructure burden. Your AI agents get dynamic, documentation-driven access to ZoomInfo's enrichment and intent endpoints instantly, while you maintain strict control over credit usage, security, and authentication lifecycles.