Coresignal MCP v2

The official Model Context Protocol server for Coresignal — bring fresh B2B data on 895M+ employees, 70M+ companies, and 468M+ job postings straight into your AI assistant.

https://mcp.coresignal.com/mcp/v2

Search in plain natural language, pull full records, enrich contacts with verified emails, and export large result sets as downloadable files — all from Claude, Cursor, Codex, VS Code, or any other MCP-compatible client.

Features

• OAuth 2.1 authentication — sign in with your Coresignal dashboard account; no API keys in config files.
• Natural-language search with match evidence in every result row, so you can see why each record matched.
• Cost transparency — every response reports credits_consumed, and expensive calls ask for confirmation before spending.
• Field discovery — entity_fields finds the right field names by keyword, free, without loading the full 300+ field vocabulary into context.
• File downloads — large result sets are stored server-side and returned as a download link instead of flooding the chat.
• artifact_read pages delivered files back into the conversation for free — works even in clients with no filesystem access.

Prerequisites

• A Coresignal account with an active subscription (credits) and a team API key provisioned in the dashboard. The MCP server resolves your team's key automatically after sign-in — you never paste it into a config file. No subscription yet? Start with the 7-day free trial — it includes 2,000 credits. See the plan comparison.

On first connection your client opens a browser window to sign in to the Coresignal dashboard. That's the whole setup — no environment variables, no secrets.

Client setup

claude mcp add --transport http coresignal https://mcp.coresignal.com/mcp/v2

codex mcp add coresignal --url https://mcp.coresignal.com/mcp/v2

{
  "mcpServers": {
    "coresignal": {
      "url": "https://mcp.coresignal.com/mcp/v2"
    }
  }
}

opencode mcp add coresignal --url https://mcp.coresignal.com/mcp/v2

opencode mcp auth coresignal

{
  "servers": {
    "coresignal": {
      "type": "http",
      "url": "https://mcp.coresignal.com/mcp/v2"
    }
  }
}

{
  "mcpServers": {
    "coresignal": {
      "type": "streamableHttp",
      "url": "https://mcp.coresignal.com/mcp/v2",
      "disabled": false
    }
  }
}

cline mcp

File downloads & the domain allowlist

Large results (and any call with delivery="url") are not dumped into the chat to save LLM input tokens. Instead the server stores the rows as a file and returns a signed HTTPS download link that expires after 1 hour:

{
  "delivery": "url",
  "url": "https://mcp.coresignal.com/mcp/v2/artifacts/…?exp=…&sig=…",
  "artifact_name": "employee_fetch-baf941dd4f8c4dfe.jsonl",
  "count": 500,
  "credits_consumed": 10000
}

From here, the agent gets at the data in one of three ways:

1. The agent downloads the file itself — in clients with shell access, the agent will typically curl the link to disk and analyze the file locally with grep/jq/pandas.
2. The agent reads it back in-chat — in clients with no shell and no filesystem, the agent calls artifact_read(artifact_name, offset, limit) instead, paging through the file in slices over the MCP session. This is free and works everywhere, so nothing floods the chat.
3. You download it manually — if the agent itself isn't allowed to fetch the link (domain not allowlisted, sandbox without network access), click the link, save the file, and tell the agent where it is: "I've downloaded the file to ~/Downloads/employee_fetch-….jsonl — analyze it from there." Works in any client that can read local files.

Prefer the download when your client supports it. artifact_read is free in Coresignal credits, but not in LLM tokens: every page it returns becomes part of the conversation and is re-billed as input tokens on each subsequent turn. Each page is also trimmed to a fixed token budget — a full employee record is ~8k tokens, so a single page carries only a handful of full records regardless of the limit you ask for. Reading a large file that way takes hundreds of calls and can exhaust the context window before you reach the end. A downloaded file costs essentially no tokens — the assistant can filter thousands of rows locally with grep/jq and surface only the answer. That's why it pays to get downloads working up front (domain allowlist, sandbox network access) and keep artifact_read for clients that can't download or for eyeballing a few rows.

If downloads are blocked, nothing is lost: the records are already stored and paid for — read them with artifact_read. Never re-run a fetch to "recover" a file; that bills every record a second time.

Tools

entity_search

Searches employee, company, or job records with a plain-language query:

"Senior Python developers at fintech companies in French"

Every call costs a flat 20 credits and returns:

• total_count — the exact number of records the query matched,
• up to 20 preview rows (limit=0 returns just the count), each showing the fields the query matched on — the evidence for why each result is there,
• a cache_id — a 1-hour handle to the search that saves credits and time: pass it to entity_fetch and the matched records are collected straight away — no need to re-run (and re-pay for) the search, and resolving the cache_id itself is free. Record ids stay server-side, so nothing bulky ever passes through the conversation.

entity_fields

Free, instant lookup of field names by meaning — "salary" finds the compensation fields, "current job title and seniority" finds active_experience_title, experience.position_title, etc. Use it to build the fields list for a custom-scope fetch without ever loading the full field vocabulary into context.

entity_fetch

Collects records — either up to 20 hand-picked ids from search results, or up to 1,000 records per call via a cache_id. Billing is per record found: 20 credits for employees/companies, 1 for jobs.

email_enrich

Verified, deliverable business emails for up to 1,000 employee ids — 10 credits per email found; not-found ids are free. EEA/UK contacts are not accessible (GDPR).

artifact_read

Reads a delivered file back over the authenticated MCP session, a page at a time — free, since the records were billed when they were fetched. This is what makes file delivery work everywhere, including chat clients that can't open a link or touch a filesystem.

Example prompts

Market scan

"Find B2B SaaS companies in the Nordics with 50–200 employees that raised funding in the last two years."

Build a lead list with verified emails

"Search for heads of data at US companies with 500+ employees. Fetch 20 full profiles to a file with verified emails."

Deep-dive a single company**

"Pull the full record for flo.health — funding rounds, headcount growth, and current job openings."

...

Credits & billing

Every response includes credits_consumed — the actual billed amount, so a discrepancy (sent 1,000 ids, billed for 950 records) tells you exactly how many ids weren't found. The server never spends silently: fetches confirm field scope with you first, and a fetch that can't be delivered fails before any credits are spent.

Credits are drawn from your team's Coresignal subscription — manage keys and billing in the dashboard. New to Coresignal? The 7-day free trial comes with 2,000 credits — that's 100 searches, or 100 employee/company records, or a mix — see the plan comparison.

Links

• Coresignal — data coverage, plans, and pricing
• Coresignal dashboard — account, team, API keys, credits
• API documentation — the underlying data APIs