Meta Agent Tools
PT

Back to the catalog

com.coresignal/mcp

Fresh company, employee, and jobs records in real time.

Open source Repository Open in the app JSON README (API)

About

Fresh company, employee, and jobs records in real time.

Details

Kind
MCP servers
Topic
No topic detected
Publisher
com.coresignal
Origin
official
Category
ferramentas
Transport
http
Version
2.0.0
Stars
2
Forks
3
Last push
2026-08-07T09:18:11Z
Repository state
ativo
Added
2026-08-29 03:01:04
Updated
2026-08-29 03:01:04
Origin id
com.coresignal/mcp

README

# Coresignal MCP v2

The official [Model Context Protocol](https://modelcontextprotocol.io) server for [Coresignal](https://coresignal.com) — bring fresh B2B data on **895M+ employees**, **70M+ companies**, and **468M+ job postings** straight into your AI assistant.

```bash
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](https://dashboard.coresignal.com) 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](https://coresignal.com/pricing/#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

<details>
<summary><b>Claude Desktop</b></summary>

Claude Desktop supports remote MCP servers natively via **Connectors**:

1. Open **Settings → Connectors → Add custom connector**.
2. Name: `Coresignal`, URL: `https://mcp.coresignal.com/mcp/v2`.
3. Click **Add**, then **Connect** — a browser window opens to sign in to your Coresignal dashboard account.

> **Important — enable file downloads:** Claude Desktop blocks downloads from domains it doesn't know. To download result files (large fetches are delivered as links), add `mcp.coresignal.com` to the **Domain allowlist** in Claude Desktop settings (on Team/Enterprise plans your admin manages this). Without it, download links from the server will be blocked — though you can always read the data back in-chat with the free `artifact_read` tool instead. See [File downloads](#file-downloads--the-domain-allowlist).

</details>

<details>
<summary><b>Claude Code</b></summary>

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

Then inside a session run `/mcp`, select **coresignal**, and complete the browser sign-in. Re-run `/mcp` any time you need to re-authenticate.

</details>

<details>
<summary><b>Codex (OpenAI Codex CLI)</b></summary>

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

A browser window opens to sign in to your Coresignal dashboard account.

</details>

<details>
<summary><b>Cursor</b></summary>

Add to `~/.cursor/mcp.json`:

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

Cursor detects that the server requires authentication and shows a **Needs login** prompt — click it to complete the browser sign-in.

</details>

<details>
<summary><b>OpenCode</b></summary>

Add Coresignal MCP:

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

Authenticate:

```bash
opencode mcp auth coresignal
```

A browser window opens to sign in to your Coresignal dashboard account.

</details>

<details>
<summary><b>Visual Studio Code</b></summary>

Run **MCP: Add Server** from the Command Palette, choose **HTTP**, and enter the URL — or add to `.vscode/mcp.json`:

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

VS Code prompts you to authorize the server on first use and handles the OAuth flow in your browser.

</details>

<details>
<summary><b>Cline</b></summary>

Add to `~/.cline/data/settings/cline_mcp_settings.json`:

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

Open Cline MCP interface:

```bash
cline mcp
```

From menu select **Authorize OAuth** and select **coresignal**. Cline will handle the OAuth flow in your browser.

</details>

---

## 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**:

```json
{
  "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

| Tool | What it does | Cost |
| --- | --- | --- |
| `entity_search` | Natural-language search over employees, companies, or jobs | 20 credits per search (flat) |
| `entity_fields` | Keyword search over an entity's ~300 field names | Free |
| `entity_fetch` | Pull full (JSONL) or projected records, by search handle or by id | 20 credits per employee/company record, 1 per job record |
| `email_enrich` | Verified business emails for employee ids (CSV) | 10 credits per email **found** (misses are free) |
| `artifact_read` | Page rows back out of a delivered file | Free |

### `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

| Action | Credits |
|---|---|
| `entity_search` (any `limit`, including 0) | 20 per search |
| `entity_fetch` — employee or company | 20 per record found |
| `entity_fetch` — job | 1 per record found |
| `email_enrich` | 10 per email found; misses free |
| `entity_fields`, `artifact_read` | Free |

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](https://dashboard.coresignal.com). 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](https://coresignal.com/pricing/#plan-comparison).

## Links

- [Coresignal](https://coresignal.com) — data coverage, plans, and pricing
- [Coresignal dashboard](https://dashboard.coresignal.com) — account, team, API keys, credits
- [API documentation](https://docs.coresignal.com/api) — the underlying data APIs

[![smithery badge](https://smithery.ai/badge/coresignal/coresignal)](https://smithery.ai/servers/coresignal/coresignal)

More