---
title: "Connect Cognism to Claude: Discover and Enrich High-Value Accounts"
slug: connect-cognism-to-claude-discover-and-enrich-high-value-accounts
date: 2026-09-13
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to connect Cognism to claude using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows."
canonical: https://truto.one/blog/connect-cognism-to-claude-discover-and-enrich-high-value-accounts/
---

# Connect Cognism to Claude: Discover and Enrich High-Value Accounts


If you need to connect Cognism to Claude to automate B2B prospecting, orchestrate account enrichment, or perform automated compliance scrubs on your outbound lists, 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 the translation layer between Claude's tool calls and Cognism's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). 

If your team uses ChatGPT, check out our guide on [connecting Cognism to ChatGPT](https://truto.one/connect-cognism-to-chatgpt-search-filter-and-redeem-prospect-data/) or explore our broader architectural overview on [connecting Cognism to AI Agents](https://truto.one/connect-cognism-to-ai-agents-automate-prospecting-and-compliance/).

Giving a Large Language Model (LLM) read and write access to a premium global sales intelligence platform like Cognism is an engineering challenge. You have to handle API key lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Cognism's unique credit-based redemption models. Every time Cognism updates an endpoint or alters a firmographic data attribute, 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 Cognism, connect it natively to Claude Desktop, and execute complex prospecting workflows using natural language.

> Want to give your AI agents secure, authenticated access to Cognism and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Cognism 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 data APIs is painful. Cognism is built to serve highly regulated, compliant B2B data under a strict commercial model, and its API reflects that complexity.

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

**The Search-to-Redeem Architecture**
Unlike a [standard CRM API](https://truto.one/unified-api-vs-individual-integrations-which-is-right-for-you/) where `GET /contacts/:id` returns a full record, Cognism operates on a Search-to-Redeem model to manage data credits. When you search for a contact, the API returns a preview record (name, job title, company) alongside a `redeemId`. To get the actual phone number or email address, you must make a secondary call to the Redeem API, which consumes a credit from your subscription. An LLM inherently wants to pull data in one step. You must build specific tool descriptions that explicitly instruct Claude on this two-step architecture, or it will hallucinate missing fields.

**Match Scores and Enrichment Thresholds**
When enriching accounts or contacts, Cognism returns a `matchScore` alongside preview flags (e.g., `hasRevenue`, `hasTechnologies`). By default, the `minMatchScore` is set to 30 for contacts and 40 for accounts. Scores below 27 for contacts or 35 for accounts indicate low-quality matches. If you blindly feed enrichment results back to Claude without handling these thresholds, the LLM will confidently append low-quality or completely incorrect company data into your CRM. Your MCP server must either filter these programmatically or provide the LLM with the context needed to reject low-confidence matches.

**Entitlement-Gated Payloads**
Cognism's API responses mutate based on your exact subscription tier (Contact Entitlements vs. Account Entitlements). A field like mobile phone numbers or specific intent data might literally disappear from the JSON response if the authenticated account lacks the correct tier. If your MCP tools hardcode these schemas as `required`, tool calls will fail dynamically based on the customer's billing state. 

**Strict Rate Limits and Raw 429s**
When you hit Cognism's rate limits (which happens easily during bulk account enrichment workflows), the API returns HTTP 429 Too Many Requests. It is critical to understand how this is handled in a managed environment: 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 the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The AI agent or the client connecting to the MCP server is entirely responsible for implementing its own retry and backoff logic.

## How to Generate the Cognism MCP Server

Instead of building a proxy server from scratch to handle these architectural quirks, you can use Truto to dynamically generate an MCP server. Truto derives the tool definitions directly from the integration's resource configurations and automatically injects the correct JSON schemas for Cognism's Search and Redeem endpoints.

Every MCP server is fully self-contained. The generated URL contains a cryptographic token that securely routes requests to the specific integrated Cognism account, meaning no additional authentication configuration is needed on the client side.

You can create this MCP server in two ways: through the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

For internal workflows, local development, or one-off agent deployments, generating the server via the dashboard is the fastest path.

1. Log into your Truto environment.
2. Navigate to the **Integrated Accounts** page and select your connected Cognism instance.
3. Click on the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., filter for specific tags like `search` or restrict to `read` operations).
6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

If you are building an AI application and need to provision Cognism access for your users dynamically, you can generate the MCP server programmatically. This is ideal for [multi-tenant SaaS products](https://truto.one/building-multi-tenant-ai-agents-at-scale/).

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

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_COGNISM_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Cognism Enrichment Agent Server",
    "config": {
      "methods": ["read", "create", "custom"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The API returns a secure, ready-to-use URL:

```json
{
  "id": "mcp_srv_99887766",
  "name": "Cognism Enrichment Agent Server",
  "config": { "methods": ["read", "create", "custom"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can connect it to Claude. Depending on your team's workflow, you can add it via the user interface or mount it directly via a configuration file for local development.

### Method 1: Via the Claude UI

If your organization uses Claude Enterprise or Claude for Teams, you can add the connector directly in the application settings.

1. Open Claude and navigate to **Settings**.
2. Click on **Integrations** (or **Connectors**, depending on your release version).
3. Select **Add MCP Server** or **Add custom connector**.
4. Paste the Truto MCP URL you generated in the previous step.
5. Click **Add**.

Claude will immediately execute the MCP `initialize` handshake, request the `tools/list` payload, and surface the Cognism tools to your agent.

*(Note: If you are using ChatGPT Desktop, the process is similar: **Settings → Apps → Advanced settings → Developer mode → Add new server**, then paste the Truto URL.)*

### Method 2: Via Manual Config File (Claude Desktop)

If you are running Claude Desktop locally for engineering and development, you can mount the MCP server using the `claude_desktop_config.json` file. Truto's MCP servers communicate over Server-Sent Events (SSE), so you will use the official `@modelcontextprotocol/server-sse` package.

1. Locate your configuration file:
   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
2. Add the Truto MCP URL to the `mcpServers` object:

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

3. Restart Claude Desktop. The app will parse the config, execute the `npx` command to establish the SSE connection, and register the available Cognism tools.

## Hero Tools for Cognism Workflows

Truto automatically generates tools based on the available Cognism documentation and your specific environment configuration. Here are the most critical operations for an AI agent performing B2B prospecting.

### list_all_cognism_search_contacts

This tool executes complex searches against Cognism's contact database. It supports up to 1000 search terms per array field, allowing Claude to query by name, job title, location, seniority, and specific account attributes. Because it returns preview records, the LLM will extract the `redeemId` for any high-value prospects it wishes to pursue.

> "Find VP of Engineering and CTO contacts located in New York or London who work at companies with the NAICS code for Software Publishers. Return a summary of the top 5 matches with their redeem IDs."

### cognism_contacts_redeem

This is the execution mechanism that actually retrieves contact details (emails, phone numbers) and consumes a credit from your Cognism account. Claude must pass an array of up to 20 `redeemIds` obtained from either a Search or Enrich tool call.

> "Take the 3 redeem IDs you just found for the engineering leaders in London and redeem them. Extract their mobile phone numbers and verified email addresses, then format them into a CSV block."

### list_all_cognism_search_accounts

This tool allows the agent to build target account lists based on firmographics. It queries by domain, industry, technology stack, revenue, and headcount. It returns account records with preview flags (e.g., `hasRevenue`, `hasTechnologies`) that inform the LLM what data points are available before it spends credits to redeem the full account profile.

> "Search for accounts in the financial services industry based in the UK with a headcount between 500 and 1000 that use [Salesforce](https://truto.one/connect-salesforce-to-ai-agents-with-mcp/). List the first 10 accounts and indicate if they have LinkedIn URLs available."

### cognism_accounts_enrich

Enrichment allows Claude to take sparse data (like a raw domain name or a fragmented company name) and match it against Cognism's dataset. The tool returns a `matchScore`. By default, scores below 35 indicate low quality. The LLM can use this tool to validate inbound leads before proceeding with CRM updates.

> "Enrich the account for 'acmecorp.com'. If the match score is above 40, check which data flags are available and redeem the account. If the match score is below 40, flag it as a low-quality match and stop."

### cognism_compliance_list_opt_outs

Before launching an outbound campaign, Claude can utilize this tool to cross-reference target lists against Cognism's global opt-out registry. It retrieves a paginated list of opted-out contacts, ensuring your automated workflows remain compliant with global privacy regulations.

> "Fetch the latest list of opted-out contacts from the compliance endpoint. Cross-reference this list against the 5 prospects we just redeemed, and remove any individuals who appear on the opt-out list."

To view the complete inventory of available endpoints, parameter definitions, and JSON schemas for this connector, visit the [Cognism integration page](https://truto.one/integrations/detail/cognism).

## Workflows in Action

When Claude is equipped with the Cognism MCP server, it can orchestrate multi-step data acquisition workflows that previously required [custom Python scripts](https://truto.one/why-managed-mcp-is-better-than-custom-scripts/) and manual CSV uploads. Here are real-world examples of how personas leverage this capability.

### Scenario 1: Autonomous SDR Lead Generation

An outbound Sales Development Representative (SDR) wants to build a highly targeted list of decision-makers for a new regional campaign, but only wants to spend credits on prospects that have verified contact data.

> "I need a list of Director-level IT buyers at manufacturing companies in Germany. First, search for target accounts matching this profile. Then, find the IT Directors at those specific companies. Finally, redeem the top 10 contacts to get their direct phone numbers and emails. Present the final list in a table format."

**How the agent executes this:**
1. Calls `list_all_cognism_search_accounts` passing `{ "industries": ["Manufacturing"], "locations": ["Germany"] }` to gather target account IDs.
2. Calls `list_all_cognism_search_contacts` filtering by the retrieved account IDs and `{ "seniority": ["Director"], "jobTitle": ["IT", "Information Technology"] }`.
3. Extracts the `redeemId` values from the top 10 results.
4. Calls `cognism_contacts_redeem` with the extracted IDs to consume credits and fetch the raw contact data.
5. Formats the final response containing emails and direct dials.

```mermaid
graph TD
    A["Claude (SDR Agent)"] -->|"1. Search Accounts"| B["list_all_cognism_search_accounts"]
    B -->|"Account IDs"| A
    A -->|"2. Search Contacts"| C["list_all_cognism_search_contacts"]
    C -->|"Preview & redeemIds"| A
    A -->|"3. Redeem Contacts"| D["cognism_contacts_redeem"]
    D -->|"Full Contact Data (Email/Phone)"| A
```

### Scenario 2: RevOps Automated Enrichment & Compliance Scrub

A Revenue Operations manager drops a list of raw domain names from a recent webinar into the chat and asks Claude to enrich them while ensuring strict [GDPR compliance](https://truto.one/automate-gdpr-data-privacy-with-ai-agents/).

> "Here is a list of 5 domains from our recent webinar: acme.com, globex.io, soylent.corp, initech.com, and umbrellacorp.com. Please enrich these accounts to find their industry and revenue. If the match score is good, find the VP of Marketing at each company. Before giving me their emails, check the opt-out endpoint to ensure we are allowed to email them."

**How the agent executes this:**
1. Loops through the domains and calls `cognism_accounts_enrich` for each.
2. Evaluates the `matchScore` returned by the tool. If the score is >35, it proceeds.
3. Calls `cognism_accounts_redeem` to get the full company firmographics (industry, revenue).
4. Calls `list_all_cognism_search_contacts` for the validated accounts targeting the "VP of Marketing" title, then calls `cognism_contacts_redeem`.
5. Calls `cognism_compliance_get_opt_out_by_email` for each resulting email address. If the endpoint returns HTTP 200 (opted out), the agent strips the contact from the final deliverable.

## Security and Access Control

Granting an LLM autonomous access to a platform that charges per data redemption requires strict guardrails. Truto's MCP architecture enforces security at the server level, meaning you do not have to rely solely on the LLM's system prompt to prevent unwanted API calls.

*   **Method Filtering:** When creating the server via the `/mcp` endpoint, you can restrict the agent's capabilities using the `config.methods` array. For example, passing `["read"]` will allow the agent to use `list_all_cognism_search_contacts` (which is free) but block access to `cognism_contacts_redeem` (which costs credits).
*   **Tag Filtering:** You can group tools logically. If you only want the LLM to access compliance tools, you can instantiate the MCP server with `config.tags: ["compliance"]`, strictly scoping the agent to opt-out checks without exposing core search capabilities.
*   **Additional Authentication Layers:** By default, possession of the Truto MCP URL grants access. For higher security, setting `require_api_token_auth: true` forces the connecting client to also supply a valid Truto API token in the `Authorization` header, preventing unauthorized internal access if the URL is leaked in logs.
*   **Ephemeral Environments:** You can define a hard time-to-live using the `expires_at` field. Once the timestamp passes, the token is automatically wiped from KV storage, immediately terminating the agent's ability to query Cognism.

## Rethinking B2B Prospecting Workflows

Integrating Cognism with Claude via MCP fundamentally shifts how teams execute prospecting. Instead of spending hours navigating UIs, writing complex Boolean search strings, or writing Python scripts to stitch together enrichment APIs, users can simply state their ideal customer profile in natural language. The agent handles the complex orchestration of searching, scoring matches, navigating the redemption credit model, and verifying compliance in real-time.

By leveraging a managed MCP server architecture, engineering teams avoid the lifecycle maintenance of dealing with pagination schemas, dynamic entitlement payloads, and rate limits, while securely putting elite sales intelligence directly into the context window of their AI agents.