---
title: "Connect Bombora to ChatGPT: Track B2B Intent & Manage Account Lists"
slug: connect-bombora-to-chatgpt-track-b2b-intent-manage-account-lists
date: 2026-09-13
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect Bombora to ChatGPT using a managed MCP server. Automate B2B intent tracking, account list management, and digital audience creation."
tldr: "Connecting ChatGPT to Bombora via MCP allows AI agents to track B2B intent, manage account lists, and build custom audiences. This guide details the architecture, setup steps, and hero tools."
canonical: https://truto.one/blog/connect-bombora-to-chatgpt-track-b2b-intent-manage-account-lists/
---

# Connect Bombora to ChatGPT: Track B2B Intent & Manage Account Lists


If you need to connect Bombora to ChatGPT so your AI agents can monitor B2B intent signals, orchestrate account lists, and dynamically generate custom audiences, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This infrastructure acts as the translation layer between an LLM's natural language tool calls and Bombora's highly specific, taxonomy-driven REST APIs. 

If your team uses Claude, check out our guide on [connecting Bombora to Claude](https://truto.one/connect-bombora-to-claude-define-intent-signals-webhook-events/) or explore our broader architectural overview on [connecting Bombora to AI Agents](https://truto.one/connect-bombora-to-ai-agents-automate-intent-data-audience-sync/).

Giving a Large Language Model (LLM) read and write access to enterprise intent data is a significant engineering hurdle. You can either spend weeks [building, hosting, and maintaining a custom JSON-RPC server](https://truto.one/blog/how-to-architect-a-multi-tenant-mcp-server-for-enterprise-b2b-saas/) that maps LLM arguments into Bombora's data structures, or you can use a managed integration platform like Truto to [dynamically generate a secure, authenticated MCP server URL](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).

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

::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"}
Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
:::

## The Engineering Reality of the Bombora 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, implementing it against Bombora's API surface introduces domain-specific friction. 

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

### The Two-Step Intent Retrieval Pattern
Unlike typical REST endpoints where you issue a `GET` request and receive a payload, querying Bombora intent data requires a synchronous orchestration step. To fetch intent, clients must first `POST` to an endpoint (represented by `create_a_bombora_datum`) with specific `signalDefinitionId` or `topics` configurations. This generates a temporary `pageToken`. You must then pass this token to a subsequent `GET` request (`list_all_bombora_data`) to actually retrieve the domains and scores. If you hardcode MCP tools without orchestrating this two-step handshake, your LLM will inevitably hallucinate search parameters and fail to retrieve data.

### Taxonomy Discovery Overload
Bombora's data model relies heavily on its proprietary taxonomy—topics, firmographic company sizes, B2B personas, and install data products. An LLM cannot simply guess that "Enterprise" maps to "Large (1,000 - 4,999 Employees)" or guess a specific topic ID. Your MCP server must expose discovery tools for the LLM to query the taxonomy before it attempts to build a digital audience or request intent data. Without these reference tools, the agent will submit invalid IDs and encounter continuous HTTP 400 errors.

### Asynchronous Processing States
Operations like replacing product definitions (`bombora_signal_definition_product_definitions_bulk_update`) don't complete instantly. The signal definition enters a 'Processing' state while its topic collection is overwritten before returning to 'Available'. If your agent tries to query intent against a processing definition, the API will reject it. Custom MCP servers must implement state-checking logic to prevent the LLM from executing downstream actions prematurely.

### Opaque Payload Requirements for Account Lists
When syncing accounts to a Bombora account list (`update_a_bombora_account_list_account_by_id` or `create_a_bombora_account_list_account`), the exact JSON request body shape is often obscured behind developer-portal logins and can vary based on the specific account list type. Building static types for these payloads requires deep mapping of Bombora's internal specifications. Truto [handles this schema mapping automatically](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) based on the underlying API definitions.

## Bombora to ChatGPT Quickstart Guide

If you want the fastest path from a fresh Truto account to ChatGPT successfully calling the Bombora API, follow these steps. 

**What you need:**
- A Truto account with API access.
- Bombora client credentials.
- A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

### Step 1: Connect Bombora as an Integrated Account
In the Truto dashboard, navigate to **Integrated Accounts -> New Integrated Account**, select Bombora, and input the required credentials. Truto securely manages the token lifecycle, so ChatGPT never encounters expired authentication.

### Step 2: Grab your `integrated_account_id`
You can copy this directly from the account detail page in the Truto UI, or retrieve it programmatically via the API:

```bash
curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"
```

### Step 3: Generate a Bombora MCP Server
You can generate the MCP server URL through either the Truto UI or the API.

**Method A: Via the Truto UI**
1. Navigate to the integrated account page for your Bombora connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., restrict methods to read-only, or filter by specific tags).
5. Copy the generated MCP server URL.

**Method B: Via the API**
Make a `POST` request to scope an MCP endpoint specifically to that Bombora account. You can filter by `methods` and `tags` to constrain what the AI agent can execute:

```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": "Bombora Intent Operations",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["intent", "audience", "taxonomy"]
    }
  }'
```

The response will return a `url` field (e.g., `https://api.truto.one/mcp/<token>`). This URL contains both routing and authentication—treat it as a secure credential.

### Step 4: Connect the MCP Server to ChatGPT
You can register this MCP server natively in the ChatGPT UI or via a local configuration file if you are orchestrating a local agent.

**Method A: Via the ChatGPT UI**
1. In ChatGPT, go to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode**.
3. Under MCP servers / Custom connectors, click **Add new server**.
4. **Name:** "Bombora (Truto)"
5. **Server URL:** Paste the Truto MCP URL generated in Step 3.
6. Click **Save**. ChatGPT will immediately connect, perform the MCP initialization handshake, and list the available tools.

**Method B: Via Manual Config File (SSE Transport)**
If you are using desktop clients or frameworks that require an explicit MCP configuration file, you can utilize the standard Server-Sent Events (SSE) proxy:

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

## Hero Tools for Bombora Intent and Audience Data

Truto dynamically generates MCP tools based on the Bombora integration's underlying schema. Here are the highest-leverage tools available for your AI agents to interact with Bombora.

### 1. Topic Taxonomy Discovery
**Tool:** `list_all_bombora_topics`

Before querying intent data, the LLM must find the exact topic IDs Bombora uses. This tool lists intent topics and allows filtering by name, theme, or category.

> "Find the Bombora topic IDs related to 'Cybersecurity' and 'Data Loss Prevention'. Return the exact IDs."

### 2. Prepare Intent Data Request
**Tool:** `create_a_bombora_datum`

This is step one of the intent retrieval process. The LLM submits the target attributes, topic IDs, or signal definitions, and receives a `pageToken` required to fetch the actual data.

> "Set up an intent data request for the topics we just found. Make sure we are filtering for domains with a score over 70."

### 3. Fetch Intent Data Payload
**Tool:** `list_all_bombora_data`

Using the `pageToken` from the previous step, this tool retrieves the paginated intent data, returning the domains, scores, and score labels. *Note: Bombora limits response bodies to 10MB.*

> "Using the page token you just generated, fetch the actual intent data and list the top 10 surging domains."

### 4. Create an Account List
**Tool:** `create_a_bombora_account_list`

Allows the agent to construct a new Bombora account list from an `AccountListDefinition` body, specifying the list type and metadata.

> "Create a new Bombora account list named 'Q4 High-Intent Security Prospects'."

### 5. Sync Accounts to a List
**Tool:** `update_a_bombora_account_list_account_by_id`

Allows the LLM to submit accounts directly into a Bombora account list by posting to the list's accounts collection.

> "Take the 10 surging domains we identified and add them to the 'Q4 High-Intent Security Prospects' account list."

### 6. Build Digital Audiences
**Tool:** `create_a_bombora_digital_audience`

Allows the LLM to create a new Bombora Digital Audience Builder (DAB) custom audience for a specified data exchange, mapping topics, domains, and filters.

> "Create a new digital audience for our upcoming display campaign targeting enterprise companies showing intent on our selected topics."

For the complete inventory of Bombora tools, including tools for managing firmographics, webhook destinations, and signal definitions, visit the [Bombora integration page](https://truto.one/integrations/detail/bombora).

## Workflows in Action

Once connected, ChatGPT can orchestrate complex, multi-step workflows across the Bombora API autonomously.

### Workflow 1: End-to-End Intent Discovery and Target List Creation

A demand generation manager needs to identify companies actively researching their product category and immediately pipe them into an actionable account list.

> "Search Bombora for topics related to 'Cloud Infrastructure'. Once you find the correct IDs, pull the latest intent data for those topics. Finally, create a new Account List called 'Cloud Infra Surges Q3' and add the top 20 domains from your intent search to that list."

**Step-by-step execution:**
1. **`list_all_bombora_topics`**: The agent searches for "Cloud Infrastructure" to retrieve the correct taxonomy IDs.
2. **`create_a_bombora_datum`**: The agent submits the topic IDs to initiate the intent query and receives a `pageToken`.
3. **`list_all_bombora_data`**: The agent uses the token to retrieve the actual domains and intent scores.
4. **`create_a_bombora_account_list`**: The agent creates the container for the new list.
5. **`update_a_bombora_account_list_account_by_id`**: The agent formats the top 20 domains and POSTs them to the newly created list ID.

```mermaid
sequenceDiagram
  participant User as User
  participant GPT as ChatGPT
  participant Truto as Truto MCP
  participant Bombora as Bombora API

  User->>GPT: "Find surging accounts for 'Cloud Infrastructure'..."
  GPT->>Truto: call list_all_bombora_topics
  Truto->>Bombora: GET /v2/reference/topics
  Bombora-->>Truto: Return topic IDs
  Truto-->>GPT: Return JSON schema
  GPT->>Truto: call create_a_bombora_datum
  Truto->>Bombora: POST /v2/data
  Bombora-->>Truto: Return pageToken
  Truto-->>GPT: Return pageToken
  GPT->>Truto: call list_all_bombora_data(pageToken)
  Truto->>Bombora: GET /v2/data?pageToken=...
  Bombora-->>Truto: Return surging domains
  Truto-->>GPT: Return domain list
  GPT->>Truto: call create_a_bombora_account_list
  Truto->>Bombora: POST /v2/account-lists
  Bombora-->>Truto: Return list ID
  Truto-->>GPT: Return list ID
  GPT->>Truto: call update_a_bombora_account_list_account_by_id
  Truto->>Bombora: POST /v2/account-lists/{id}/accounts
  Bombora-->>Truto: 200 OK
  Truto-->>GPT: Success
```

### Workflow 2: Digital Audience Estimation and Deployment

A marketer wants to launch a programmatic ad campaign but needs to ensure the audience size is viable before committing budget.

> "I want to target 'Enterprise' companies in 'Manufacturing' who are researching 'Supply Chain Software'. Find the right firmographic and topic IDs, estimate the audience size, and if it's over 10,000, create a new Digital Audience for the Trade Desk data exchange."

**Step-by-step execution:**
1. **`list_all_bombora_firmographic_company_sizes`** & **`list_all_bombora_firmographic_industries`**: The agent pulls the exact reference IDs for Enterprise and Manufacturing.
2. **`list_all_bombora_topics`**: The agent finds the topic ID for "Supply Chain Software".
3. **`create_a_bombora_digital_audience_estimate`**: The agent submits the combined filter criteria to Bombora to check the count.
4. **`create_a_bombora_digital_audience`**: Seeing the count exceeds 10,000, the agent constructs the final payload and deploys the audience.

## Handling Rate Limits at Scale

When deploying AI agents against enterprise APIs, rate limits are a critical consideration. Autonomous agents can rapidly execute loops, quickly exhausting API quotas.

**Crucial architectural note:** Truto *does not* absorb, retry, or apply backoff logic to rate limit errors. If an agent's rapid execution triggers a rate limit from Bombora, Truto acts as a transparent proxy. It will pass the HTTP `429 Too Many Requests` error directly back to the calling client (the LLM framework). 

Truto normalizes the upstream rate limit information into standard IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller (your agent orchestration layer or the LLM itself) is entirely responsible for reading these headers, pausing execution, and implementing the necessary retry and exponential backoff logic.

## Security and Access Control

When exposing corporate intent data and audience creation capabilities to an LLM, strict boundaries are required. Truto MCP servers provide robust security constraints configured at the token generation layer:

*   **Method Filtering:** Restrict the MCP server to read-only operations by passing `"methods": ["read"]`. This allows the agent to research intent data and topics but prevents it from creating audiences or modifying lists.
*   **Tag Filtering:** Scope the server to specific functional areas using `"tags": ["taxonomy"]`. If set, the LLM will only see tools related to Bombora's reference data, keeping core account lists hidden.
*   **Require API Token Auth:** By setting `require_api_token_auth: true`, possession of the MCP URL alone is insufficient. The client must also pass a valid Truto API token in the `Authorization` header, enforcing identity at the agent level.
*   **Ephemeral Servers:** Use the `expires_at` parameter to generate short-lived MCP URLs. Once the timestamp passes, the server automatically self-destructs, which is ideal for temporary agent sessions.

## Build Faster Agentic Workflows

Connecting Bombora to ChatGPT shouldn't require maintaining a custom integration layer, managing OAuth state, or hand-coding JSON-RPC tool definitions. By utilizing a managed MCP server, you abstract the infrastructure overhead and let your LLMs interact natively with Bombora's powerful intent engine.

Instead of wrestling with taxonomy discovery logic and paginated intent extraction scripts, you can focus on building intelligent agents that actually drive pipeline and revenue.

::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"}
Ready to connect your AI agents to Bombora? Get started with Truto's managed MCP servers today.
:::