> For the complete documentation index, see [llms.txt](https://help.delpha.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.delpha.io/delpha-api-and-mcp/mcp.md).

# MCP

#### Model Context Protocol ( MCP )

Let your AI agents call the Delpha Data Quality APIs over the Model Context Protocol.

The Delpha MCP server exposes the same Data Quality tools as the [Delpha API](https://help.delpha.io/delpha-api-and-mcp/api) — Find, Validate, Enrich, Score — through the open MCP standard, so any MCP-compatible client (Cursor, VS Code, Claude Code, Claude.ai, ChatGPT) can use them directly. Authentication is scoped per tenant, via OAuth (recommended) or a restricted API key.

{% hint style="info" %}
**Server URL** — `https://mcp.delpha.ai/mcp`

**Auth** — OAuth 2.1 with PKCE (recommended) — sign in with your Delpha account — or a restricted API key (`Authorization: Bearer dlp_…`) for clients that can't do OAuth. Manage your connection, API keys, and team access from [app.delpha.ai](https://app.delpha.ai/settings/mcp).
{% endhint %}

#### Connect to Delpha's MCP server

{% tabs %}
{% tab title="Cursor" %}
[Install in Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=delpha\&config=eyJ1cmwiOiJodHRwczovL21jcC5kZWxwaGEuYWkvbWNwIn0%3D)

To open Cursor and automatically add the Delpha MCP, click install. Alternatively, add the following to your `~/.cursor/mcp.json` file. To learn more, see the Cursor [documentation](https://docs.cursor.com/context/model-context-protocol).

```json
{
  "mcpServers": {
    "delpha": {
      "url": "https://mcp.delpha.ai/mcp"
    }
  }
}
```

{% endtab %}

{% tab title="VS Code" %}
[Install in VS Code](https://vscode.dev/redirect/mcp/install?name=delpha\&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.delpha.ai%2Fmcp%22%7D)

To open VS Code and automatically add the Delpha MCP, click install. Alternatively, add the following to your `.vscode/mcp.json` file in your workspace. To learn more, see the VS Code [documentation](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).

```json
{
  "servers": {
    "delpha": {
      "type": "http",
      "url": "https://mcp.delpha.ai/mcp"
    }
  }
}
```

{% endtab %}

{% tab title="Claude Code" %}
To add Delpha to Claude Code, run the following command. To learn more, see the Claude Code [documentation](https://docs.anthropic.com/en/docs/claude-code/mcp#configure-mcp-servers).

```bash
claude mcp add --transport http delpha https://mcp.delpha.ai/mcp
```

After adding the server to Claude, finish authentication:

```bash
claude /mcp
```

{% endtab %}

{% tab title="Claude.ai (web)" %}
Available on Claude Pro, Team, and Enterprise plans. Open **Settings → Connectors → Add custom connector**, paste the server URL, and choose **OAuth** as the connection mechanism:

* Server URL: `https://mcp.delpha.ai/mcp`
* Connection mechanism: OAuth

Claude completes the OAuth handshake against Delpha's identity provider and you'll be redirected back to the connector once authorized.
{% endtab %}

{% tab title="ChatGPT" %}
Available on ChatGPT Pro, Plus, Business, Enterprise, and Education plans. Follow the [OpenAI documentation](https://platform.openai.com/docs/guides/developer-mode) for adding a custom connector, then use:

* Server URL: `https://mcp.delpha.ai/mcp`
* Connection mechanism: OAuth
  {% endtab %}

{% tab title="Other MCP Clients" %}
MCP is an open protocol with a growing client ecosystem. Any client that supports remote MCP servers with OAuth can connect — see the client's own documentation. The minimum configuration is:

```json
{
  "delpha": {
    "url": "https://mcp.delpha.ai/mcp"
  }
}
```

The server advertises its OAuth endpoints via the standard discovery documents at `/.well-known/oauth-protected-resource` and `/.well-known/oauth-authorization-server`, so compliant clients negotiate auth automatically.
{% endtab %}
{% endtabs %}

#### Authentication

Delpha MCP supports two credential types, scoped per tenant:

* **OAuth 2.1 with PKCE (recommended)** — every call is bound to a Delpha user account, so usage stays auditable per person. Use this whenever your client supports it.
* **API key** — a restricted `dlp_` API key sent as `Authorization: Bearer dlp_...`, for clients that can't complete an OAuth handshake. Calls are bound to the team that created the key rather than an individual user.

**OAuth 2.1 with PKCE**

1. Have a Delpha account — sign up at [app.delpha.ai](https://app.delpha.ai) (your team is created with it) or accept a teammate's invitation.
2. From your MCP client, add the connector with the server URL above.
3. Your client opens Delpha's sign-in page. Choose **Continue with DelphaAI**, sign in with your app.delpha.ai credentials, and approve the consent screen.
4. The client receives an access token bound to your team's workspace — first-time connections are set up automatically, nothing to configure. The MCP server validates the token on every request and routes tool calls to the Delpha API.

{% hint style="info" %}
Need an account? Create one at [app.delpha.ai](https://app.delpha.ai), or ask a team admin to invite you. Questions — <support.api@delpha.io>.
{% endhint %}

**API key (fallback)**

Create a key from [**Settings → API keys**](https://app.delpha.ai/settings/api-keys) — the key is shown once at creation, so copy it right away — or straight from the connect panel at [**Settings → MCP**](https://app.delpha.ai/settings/mcp). Then pass it as a bearer token instead of doing the OAuth handshake:

```json
{
  "mcpServers": {
    "delpha": {
      "url": "https://mcp.delpha.ai/mcp",
      "headers": {
        "Authorization": "Bearer dlp_live_..."
      }
    }
  }
}
```

{% hint style="warning" %}
API keys are team-wide and, until scoped keys ship, full-privilege — treat one like a password. Store it in a secrets manager, never commit it, and revoke it immediately from [Settings → API keys](https://app.delpha.ai/settings/api-keys) if it leaks. Keys expire automatically after 30 days.
{% endhint %}

#### Manage your MCP connection

Your MCP connection is managed from [**app.delpha.ai → Settings → MCP**](https://app.delpha.ai/settings/mcp):

* **Connected clients** — every client that has connected to the server (via OAuth or an API key) is listed with its name and last-seen time. **Disconnect** removes an OAuth client's connection; disconnecting a key-based client also revokes the API key behind it. **Verify** checks a fresh connection so you can confirm your setup end to end.
* **MCP access (team admins)** — a team-wide switch that turns MCP off for both authentication methods. Changes apply within about a minute.
* **API keys** — created and revoked from [Settings → API keys](https://app.delpha.ai/settings/api-keys); each key's last-used time is shown there.

**Usage & credits**

Every tool call draws from your team's Delpha credit balance — the same metering as calling the [Delpha API](https://help.delpha.io/delpha-api-and-mcp/api) directly, and new teams start with free credits. When the balance reaches zero, tool calls return a payment-required error until the team is topped up. Track your balance and history at [Settings → Billing](https://app.delpha.ai/settings/billing) and [Settings → Usage](https://app.delpha.ai/settings/usage).

#### Tools

The MCP server exposes 16 tools, grouped by workflow below. Every tool maps to a Delpha API endpoint — click *API reference* on any row to see the full request/response schema on the existing API page.

**Find & Validate**

| MCP tool                        | Objective            | Description                     | Live lookup | API reference                                                                    |
| ------------------------------- | -------------------- | ------------------------------- | ----------- | -------------------------------------------------------------------------------- |
| `findAndValidateEmail`          | Recommend / Validate | Find, validate & qualify email  | Yes         | [email](https://help.delpha.io/delpha-api-and-mcp/api/email)                     |
| `findAndValidateLegalID`        | Recommend / Validate | Find & validate legal ID        | Yes         | [legal-id](https://help.delpha.io/delpha-api-and-mcp/api/legal-id)               |
| `findAndValidateLinkedin`       | Recommend / Validate | Find & validate LinkedIn URL    | Yes         | [linkedin](https://help.delpha.io/delpha-api-and-mcp/api/linkedin)               |
| `findAndValidateName`           | Validate             | Find & validate person name     | Yes         | [name](https://help.delpha.io/delpha-api-and-mcp/api/name)                       |
| `findAndValidatePhone`          | Validate             | Find & validate phone number    | Yes         | [phone](https://help.delpha.io/delpha-api-and-mcp/api/phone)                     |
| `findAndValidateUltimateParent` | Recommend / Validate | Find & validate ultimate parent | Yes         | [ultimate-parent](https://help.delpha.io/delpha-api-and-mcp/api/ultimate-parent) |
| `findAndValidateWebsite`        | Recommend / Validate | Find & validate website         | Yes         | [website](https://help.delpha.io/delpha-api-and-mcp/api/website)                 |

**LinkedIn enrichment**

| MCP tool               | Objective | Description                | Live lookup | API reference                                                                    |
| ---------------------- | --------- | -------------------------- | ----------- | -------------------------------------------------------------------------------- |
| `submitLinkedinImport` | Enrich    | Submit LinkedIn import job | Yes         | [linkedin-import](https://help.delpha.io/delpha-api-and-mcp/api/linkedin-import) |

**Result polling**

| MCP tool                  | Objective            | Description                    | Live lookup | API reference                                                                    |
| ------------------------- | -------------------- | ------------------------------ | ----------- | -------------------------------------------------------------------------------- |
| `getEmailResult`          | Recommend / Validate | Get email validation result    | No          | [email](https://help.delpha.io/delpha-api-and-mcp/api/email)                     |
| `getLegalIDResult`        | Recommend / Validate | Get legal ID validation result | No          | [legal-id](https://help.delpha.io/delpha-api-and-mcp/api/legal-id)               |
| `getLinkedinImportResult` | Enrich               | Get LinkedIn import result     | No          | [linkedin-import](https://help.delpha.io/delpha-api-and-mcp/api/linkedin-import) |
| `getLinkedinResult`       | Recommend / Validate | Get LinkedIn validation result | No          | [linkedin](https://help.delpha.io/delpha-api-and-mcp/api/linkedin)               |
| `getNameResult`           | Validate             | Get name validation result     | No          | [name](https://help.delpha.io/delpha-api-and-mcp/api/name)                       |
| `getPhoneResult`          | Validate             | Get phone validation result    | No          | [phone](https://help.delpha.io/delpha-api-and-mcp/api/phone)                     |
| `getUltimateParentResult` | Recommend / Validate | Get ultimate-parent result     | No          | [ultimate-parent](https://help.delpha.io/delpha-api-and-mcp/api/ultimate-parent) |
| `getWebsiteResult`        | Recommend / Validate | Get website validation result  | No          | [website](https://help.delpha.io/delpha-api-and-mcp/api/website)                 |

*Live lookup* flags tools that trigger an external lookup against third-party data sources (equivalent to MCP's `openWorldHint=true`). All tools are read-only and safe to retry — re-submitting a job mints a fresh `job_id` with no side effects.

#### Tool behavior

Most Delpha tools follow an asynchronous **submit → poll** pattern:

1. The agent calls a `findAndValidate*` tool with the input data. The server returns a `job_id` immediately.
2. The agent calls the paired `get*Result` tool with that `job_id` to fetch the result. While the job is still running, the result tool returns `status_code=202` and the agent retries; on completion it returns `status_code=200` with the full result envelope.

Example pair: `findAndValidateEmail` → `getEmailResult`. Typical end-to-end latency is a few seconds.

Every result envelope shares the same shape: `{ message, status, status_code, result, process_time }`. The `result` object is entity-specific — see the linked API page for each tool for the exact fields and scoring semantics.

**Feedback**

We're actively adding tools and refining descriptions based on how agents actually use them. If you have feedback, hit a rough edge, or want to see a new capability, email us at <support.api@delpha.io>.

***

#### Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://help.delpha.io/delpha-api-and-mcp/mcp.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

We're actively adding tools and refining descriptions based on how agents actually use them. If you have feedback, hit a rough edge, or want to see a new capability, email us at <support.api@delpha.io>.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://help.delpha.io/delpha-api-and-mcp/mcp.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
