---
title: "Connect Bombora to Claude: Define Intent Signals & Webhook Events"
slug: connect-bombora-to-claude-define-intent-signals-webhook-events
date: 2026-09-13
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to connect Bombora to Claude using Truto's managed MCP server. Automate intent signal definitions, ABM account lists, and webhook event orchestration."
tldr: "Connect Bombora to Claude via a managed MCP server to automate B2B intent signal definitions, webhook destinations, and ABM account lists using natural language."
canonical: https://truto.one/blog/connect-bombora-to-claude-define-intent-signals-webhook-events/
---

# Connect Bombora to Claude: Define Intent Signals & Webhook Events


If your go-to-market team needs to connect Bombora to Claude to automate B2B intent signal tracking, manage account-based marketing (ABM) lists, or orchestrate webhook data deliveries, you need a [Model Context Protocol (MCP) server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/). This server acts as the translation layer between Claude's LLM function calls and Bombora's REST API. You can either [build and maintain this integration infrastructure yourself](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL. 

This guide focuses on Claude. If your team uses ChatGPT, check out our guide on [connecting Bombora to ChatGPT](https://truto.one/connect-bombora-to-chatgpt-track-b2b-intent-manage-account-lists/) 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 a specialized data engine like Bombora is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Bombora's domain-specific data constraints. Every time Bombora updates an endpoint or changes a taxonomy reference, 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 MCP server for Bombora, connect it natively to Claude Desktop, and execute complex intent data workflows using natural language.

> Want to give your AI agents secure, authenticated access to Bombora and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## 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, the reality of implementing it against specialized B2B intent APIs is painful. Bombora is built to process massive volumes of firmographic, demographic, and behavioral data. Its API reflects that scale and complexity.

If you decide to build a custom Bombora MCP server from scratch, here are the specific integration challenges you will face:

**Destructive Dependency Chains (HTTP 409 Conflicts)**
Bombora enforces strict referential integrity across its resources. For example, if you attempt to delete a webhook destination via the API, the request will immediately fail with an `HTTP 409 Conflict` if that destination has active event subscriptions. You must first query the destination, list its events, issue a bulk update to disable them, and then delete the destination. Similarly, you cannot delete an Account List if it is acting as a parent to a derived list. An LLM has no inherent context on these downstream dependencies. Your MCP server must expose strictly defined tools that guide the model to sequence its operations correctly.

**Payload Limits and Page Tokens**
Fetching intent data via Bombora's API is not a simple paginated CRUD list. Endpoints like the data retrieval route cap response body sizes at a hard 10MB limit. If a result set exceeds this, the API returns fewer results than your requested limit, forcing you to continuously pass a `pageToken` generated from an initial POST request. An unmanaged AI agent will easily get trapped in infinite loops or hallucinate query parameters if the schema is not explicitly instructing it to return the `pageToken` exactly as received.

**Rate Limits and 429 Handling**
Bombora, like most enterprise data providers, strictly enforces API rate limits. When a caller exceeds these limits, the API returns an `HTTP 429 Too Many Requests` status. It is a critical architectural point that Truto does not retry, throttle, or apply backoff on rate limit errors automatically. When Bombora returns a 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The calling AI agent or application framework is entirely responsible for reading these headers and executing the appropriate retry or backoff logic. Do not build an MCP client assuming the proxy will absorb these errors.

## Generating the Bombora MCP Server

Truto derives MCP tools dynamically from the underlying integration's documented API resources. Because these definitions are documentation-driven, you never have to hand-code JSON schemas for Claude. 

Every MCP server in Truto is scoped to a single integrated account (a specific authenticated connection to a Bombora instance). You can generate the server URL through the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

If you are setting up Claude Desktop for internal use, the UI is the fastest path:

1. Log into your Truto dashboard and navigate to your **Integrated Accounts**.
2. Select your connected Bombora account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Configure the server (e.g., name it "Bombora Intent Prod", select permitted methods like `read` or `write`).
6. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

If you are dynamically provisioning Claude-powered workspaces for your users, you should generate the MCP server programmatically. 

Make a `POST` request to `/integrated-account/:id/mcp`. You can pass a configuration object to restrict the server to specific HTTP methods or tags.

```bash
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": "Bombora Intent Signals",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The API validates the configuration, generates a secure cryptographic token, and returns the URL. This URL encapsulates both the routing and the authentication for the specific Bombora tenant.

```json
{
  "id": "mcp_srv_9x8y7z6",
  "name": "Bombora Intent Signals",
  "config": {
    "methods": ["read", "write", "custom"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0"
}
```

## Connecting the MCP Server to Claude

Once you have the Truto MCP URL, you need to register it with Claude. Because the URL contains the cryptographic token, no additional headers are required (unless you explicitly enabled `require_api_token_auth`).

### Method A: Via the Claude UI

If you are using a Claude plan that supports UI-based custom connectors (e.g., Team or Enterprise):

1. Open Claude and navigate to **Settings**.
2. Click on **Integrations** (or **Connectors** depending on your specific Claude tier).
3. Select **Add MCP Server** or **Add custom connector**.
4. Paste the Truto MCP URL (`https://api.truto.one/mcp/...`) and click **Add**.

Claude will immediately ping the endpoint, execute the MCP handshake, and discover the available Bombora tools.

### Method B: Via the Claude Desktop Config File

For developers using the standard Claude Desktop application, you configure the server via the `claude_desktop_config.json` file. Truto provides an NPM package (`@modelcontextprotocol/server-sse`) that translates Claude's standard local stdio communication into Server-Sent Events (SSE) over HTTP.

Open your Claude Desktop configuration file (usually located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add the following JSON:

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

Restart Claude Desktop. The application will initialize the SSE connection, fetch the Bombora schemas, and the tools will appear as an available attachment in your chat interface.

## Hero Tools for Bombora Intent Workflows

Truto automatically generates a comprehensive suite of tools based on Bombora's API documentation. Here are 6 high-leverage hero tools that transform Claude from a simple chatbot into a B2B intent orchestration engine.

### 1. `get_single_bombora_signal_definition_by_id`

Before modifying intent signals, Claude needs to inspect the current state of a signal definition. This tool returns the full definition, including its ID, status, topic count, and the exact metadata configuration applied to it.

**Contextual Usage:** Use this when you need to audit an existing signal to understand why certain accounts are scoring high, or to verify topics before running a bulk update.

> "Fetch the configuration for the Bombora signal definition ID `sig_88492`. I need to see the exact topic count and metadata description before we add new competitor keywords."

### 2. `create_a_bombora_signal_definition`

This is the core operational tool for defining what intent looks like. It accepts a payload of product data points - such as domains, keywords, and URLs - and creates a new signal definition in Bombora.

**Contextual Usage:** Claude can take a natural language description of a new product launch or competitor and translate it into the strict metadata schema Bombora requires to start tracking intent.

> "Create a new Bombora signal definition for our upcoming AI product launch. Target the keywords 'machine learning orchestration', 'MLOps', and 'LLM routing'. Name the signal 'Q4 AI Product Intent'."

### 3. `list_all_bombora_account_lists`

Account Lists (ABM lists) are the foundation of targeting in Bombora. This tool retrieves paginated lists of all account lists, returning their IDs, names, pending update status, and modification dates.

**Contextual Usage:** Before Claude can extract intent data for a specific set of target accounts, it needs to find the correct list ID from the environment.

> "List all available Bombora account lists. Find the one named 'Tier 1 Enterprise Retail Targets' and give me its ID and last modified date."

### 4. `create_a_bombora_destination`

Bombora relies heavily on webhook destinations to push intent data events to your infrastructure. This tool creates a new destination endpoint that can later be subscribed to specific event types.

**Contextual Usage:** When setting up a new intent ingestion pipeline in your CRM or data warehouse, Claude can provision the required Bombora webhook target.

> "Create a new Bombora webhook destination called 'Snowflake Intake Prod'. Point the address to `https://ingest.example.com/bombora/webhook` and set a description indicating it handles enterprise intent events."

### 5. `bombora_events_bulk_update`

Creating a destination is only step one. To actually receive data, you must subscribe that destination to events. This tool replaces the event subscription document for a destination, allowing you to enable or disable specific event types.

**Contextual Usage:** Use this tool immediately after creating a destination, or when an engineering team needs to temporarily halt a specific data feed to debug a downstream issue.

> "Update the event subscriptions for destination ID `dest_7473`. Enable the 'intent_surge_detected' event type and ensure all other event types are disabled."

### 6. `list_all_bombora_data`

This tool retrieves the actual paginated intent data from Bombora. It requires a `pageToken` obtained from a corresponding POST request, and returns objects containing the domain, score, and score label for organizations showing intent.

**Contextual Usage:** This is the analytical powerhouse tool. Claude uses it to fetch raw intent scores and summarize which companies are surging on your defined topics.

> "Using the page token `pt_9948abc`, fetch the next batch of Bombora intent data. Filter the response and summarize the domains that have a score above 85, categorized by their score label."

For the complete inventory of available Bombora tools, including firmographic references, demographic filters, and digital audience creation, view the [Bombora integration page](https://truto.one/integrations/detail/bombora).

## Workflows in Action

When you connect Bombora to Claude via an MCP server, you move beyond simple API wrappers. Claude can orchestrate multi-step data engineering and marketing operations autonomously.

### Workflow 1: Configure a New Competitor Intent Signal and Webhook Delivery

Marketing ops often needs to spin up tracking for a new competitor and pipe that data directly to a Slack alert system or CRM via webhooks. Claude can handle this end-to-end.

> "We have a new competitor, AcmeCorp. Create a Bombora signal definition tracking their domain 'acmecorp.com' and the keywords 'Acme migration' and 'Acme pricing'. Once that is created, provision a new webhook destination pointing to `https://api.ourcrm.com/webhooks/intent` and subscribe it to surge events."

**Execution Steps:**
1. Claude calls `create_a_bombora_signal_definition`, passing the metadata with the domain and keywords, and receives the new `signalDefinitionId`.
2. Claude calls `create_a_bombora_destination` with the provided URL, returning a `destinationId`.
3. Claude calls `bombora_events_bulk_update` using the new `destinationId`, enabling the intent surge event type.

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude
    participant MCP as Truto MCP Server
    participant Bombora as Bombora API

    User->>Claude: "Create signal for AcmeCorp and setup webhook..."
    Claude->>MCP: Call create_a_bombora_signal_definition
    MCP->>Bombora: POST /v2/signal-definitions
    Bombora-->>MCP: Returns signalDefinitionId
    MCP-->>Claude: Tool result (Success)
    
    Claude->>MCP: Call create_a_bombora_destination
    MCP->>Bombora: POST /v2/destinations
    Bombora-->>MCP: Returns destinationId
    MCP-->>Claude: Tool result (Success)
    
    Claude->>MCP: Call bombora_events_bulk_update
    MCP->>Bombora: PUT /v2/destinations/{id}/events
    Bombora-->>MCP: 200 OK (Events enabled)
    MCP-->>Claude: Tool result (Success)
    Claude->>User: "Signal created and webhook destination subscribed successfully."
```

**Result:** The user gets a confirmation that the intent signal is actively tracking the competitor and the data pipeline is fully provisioned, eliminating manual setup in the Bombora developer portal.

### Workflow 2: Audit ABM Lists and Extract High-Intent Target Accounts

Sales teams need to know which accounts on their named target lists are currently researching relevant topics. Claude can locate the list, generate the request, and analyze the results.

> "Find the Bombora account list named 'Q3 Healthcare Targets'. Once you have the ID, initiate a data fetch for it and retrieve the first page of intent data. Tell me which top 5 domains have the highest intent scores."

**Execution Steps:**
1. Claude calls `list_all_bombora_account_lists` to search the directory and extracts the ID for 'Q3 Healthcare Targets'.
2. Claude calls `create_a_bombora_datum` (the POST counterpart for data retrieval), passing the list ID to generate a `pageToken`.
3. Claude calls `list_all_bombora_data` using the `pageToken` to fetch the first batch of results.
4. Claude analyzes the JSON payload, sorts by score, and formats the response.

```mermaid
flowchart TD
    A["User Prompt<br>Analyze Q3 Healthcare Targets"] --> B["list_all_bombora_account_lists<br>Find list ID"]
    B --> C["create_a_bombora_datum<br>POST for pageToken"]
    C --> D["list_all_bombora_data<br>Fetch intent payload"]
    D --> E["Claude sorts and filters scores"]
    E --> F["Final Output<br>Top 5 domains by intent"]
```

**Result:** The sales rep receives an immediate, actionable list of the top 5 surging healthcare accounts without having to log into a dashboard or run a manual CSV export.

## Security and Access Control

Giving an AI agent access to enterprise intent data and webhook infrastructure requires strict guardrails. Truto provides four mechanisms to secure your Bombora MCP server:

*   **Method Filtering:** Configure `config.methods: ["read"]` to allow Claude to query intent scores and account lists, but prevent it from creating or deleting signal definitions and webhooks.
*   **Tag Filtering:** Use `config.tags` to limit the server's tools to specific Bombora resources (e.g., exposing only `destinations` and `events` for a DevOps agent, while hiding `firmographic` data).
*   **Expiration (TTL):** Set an `expires_at` ISO datetime when generating the server. Once the timestamp passes, the server URL automatically expires and all KV entries are purged.
*   **Require API Token Auth:** Enable `require_api_token_auth: true`. This disables public token-only access, forcing the MCP client to also pass a valid Truto API token in the `Authorization` header, adding a critical second layer of enterprise authentication.

## Moving from Manual Plumbing to Intent Orchestration

Connecting Bombora to Claude via a managed MCP server removes the friction of API lifecycle management. You don't have to worry about mapping Bombora's 10MB payload restrictions, handling strict 409 dependency rules, or maintaining OAuth 2.0 flows. 

By leveraging Truto's auto-generated tools, your engineering team can stop building point-to-point API wrappers and start focusing on what matters: turning raw B2B intent signals into autonomous sales and marketing workflows.

> Ready to give your AI agents production-ready access to Bombora? Book a demo to see Truto's [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) in action.
>
> [Talk to us](https://truto.one/book-a-demo/)