> ## Documentation Index
> Fetch the complete documentation index at: https://docs.extend.ai/llms.txt
> Use this file to discover all available pages before exploring further.
>
> ## API version
> The current API version is `2026-02-09`, served at the site root (no version prefix in URLs).
> If this page URL contains `/2025-04-21/` or `/2024-12-23/`, you are reading an older API version.
> Prefer the current docs at https://docs.extend.ai/llms.txt unless the user explicitly needs that older version.
> Do not treat older-version pages as the source of truth for new integrations.

# Using Extend via MCP

> Connect Cursor, Claude, ChatGPT, and other AI clients to Extend's document processing platform with the Extend MCP server.

The Extend MCP (Model Context Protocol) server lets AI clients use Extend directly from chat. They can parse documents, extract structured data, classify and split files, detect and fill PDF forms, build and run workflows, manage files and webhooks, evaluate processor accuracy, and create and publish reusable resources without writing integration code.

Connect any MCP client that supports remote servers to `https://mcp.extend.ai/mcp`. Nothing needs to be installed; complete the OAuth sign-in when your client prompts you.

## How it works

Your MCP client talks to the Extend MCP server, which calls the Extend API on your behalf. When you connect with OAuth, a browser window opens to sign in to Extend and approve access. The consent flow names the client that's asking and lets you choose exactly which workspaces it may use and, for each workspace, whether it can act in the [Test Environment](/general/test-environment-guide), Production, or both. The connection is scoped to those choices; nothing outside them is reachable, and you can change them any time by reconnecting.

## Connect from your client

#### Cursor

Add the following to your `~/.cursor/mcp.json` file (or a project's `.cursor/mcp.json`), then complete the OAuth sign-in when Cursor prompts you:

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

#### Claude Code

Add the server, then run `/mcp` and select **extend** to complete the OAuth sign-in:

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

#### Claude

In Claude (web or desktop), go to **Settings** > **Connectors** > **Add custom connector** and enter:

```
https://mcp.extend.ai/mcp
```

#### VS Code

To use the server with GitHub Copilot, add the following to your workspace's `.vscode/mcp.json` file:

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

#### ChatGPT

MCP connectors require a paid ChatGPT plan. Follow the [OpenAI documentation](https://platform.openai.com/docs/guides/developer-mode) to add a custom connector with:

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

#### Codex

```bash
codex mcp add extend --url https://mcp.extend.ai/mcp
```

#### Windsurf

Add the following to your `~/.codeium/windsurf/mcp_config.json` file:

```json
{
  "mcpServers": {
    "extend": {
      "serverUrl": "https://mcp.extend.ai/mcp"
    }
  }
}
```

#### Other clients

MCP is an open protocol, and any client that supports remote servers (Streamable HTTP) can connect. Use the server URL `https://mcp.extend.ai/mcp` with OAuth as the connection mechanism. For JSON-configured clients:

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

### Limit available tools

The server exposes every tool by default. For token-sensitive clients, append a comma-separated list of group or tool names in the `tools` query parameter. The available groups are `extract`, `classify`, `parse`, `split`, `workflows`, `edit`, `files`, `webhooks`, and `evaluations`. For example, `https://mcp.extend.ai/mcp?tools=extract,files` exposes the extraction and file groups.

## How to use it

Once connected, talk to your agent in terms of outcomes and let it pick the tools. These are the things people most often do:

**Try Extend on your own documents.** Drop in a few real files and see what comes back before you build anything: parse a contract, pull fields from an invoice, classify a document, or fill a form.

> "Parse this PDF and summarize the key terms."
>
> "Extract the vendor, invoice number, line items, and total from these invoices into a table."
>
> "Fill out this W-9 with our company details."

**Build a processor without leaving chat.** Have the agent draft an extractor, classifier, or splitter for your document type, test it against samples, tighten the schema where it misses, and publish a version when the results look right.

> "Create an extractor for utility bills, test it on these three samples, and publish it."

**Measure accuracy with an evaluation.** Turn documents with known-correct answers into an evaluation set, run a processor version against it, and review where it agrees and disagrees with the ground truth.

> "Build an evaluation set from these labeled invoices and measure the extractor's accuracy."

**Check on and operate what's already running.** Inspect runs, diagnose failures, cancel or re-run documents, and manage webhooks without opening the dashboard.

> "Set up a webhook so my app is notified when runs finish."

Long-running work is handled for you: the agent starts a run, waits, and resumes checking until it finishes. Workflow runs can take minutes to hours, and that's normal. If a workflow pauses for human review, the agent hands you a dashboard link to review and approve.

## Tools

The default connection exposes the complete tool surface. You can limit product tools with the tool-selection setting described above; access and documentation tools remain available so your agent can authenticate, select the right workspace, and look up current guidance.

### Access and Documentation Tools

* List the workspaces and environments available to the connection: `get_me`
* Read a specific Extend documentation page: `get_documentation`
* Search the Extend documentation: `search_documentation`

### Parsing Tools

* Convert a PDF, image, Office document, or spreadsheet into structured markdown or raw blocks: `parse_document`
* Check, list, or delete parse runs: `get_parse_run`, `list_parse_runs`, `delete_parse_run`
* Parse up to 1,000 documents in one batch and check its status: `run_parse_batch`, `get_parse_batch`

### Extraction Tools

* Extract structured fields, tables, and line items with a saved extractor or an inline schema: `extract_data`
* Create, update, retrieve, and list extractors: `create_extractor`, `update_extractor`, `get_extractor`, `list_extractors`
* List and publish extractor versions: `list_extractor_versions`, `publish_extractor_version`
* Check, list, cancel, or delete extraction runs: `get_extract_run`, `list_extract_runs`, `cancel_extract_run`, `delete_extract_run`
* Extract from up to 1,000 documents in one batch and check its status: `run_extract_batch`, `get_extract_batch`

### Classification Tools

* Classify a document with a saved classifier or an inline set of document types: `classify_document`
* Create, update, retrieve, and list classifiers: `create_classifier`, `update_classifier`, `get_classifier`, `list_classifiers`
* List and publish classifier versions: `list_classifier_versions`, `publish_classifier_version`
* Check, list, cancel, or delete classification runs: `get_classify_run`, `list_classify_runs`, `cancel_classify_run`, `delete_classify_run`
* Classify up to 1,000 documents in one batch and check its status: `run_classify_batch`, `get_classify_batch`

### Splitting Tools

* Split a multi-document file into page ranges with a saved splitter or an inline configuration: `split_document`
* Create, update, retrieve, and list splitters: `create_splitter`, `update_splitter`, `get_splitter`, `list_splitters`
* List and publish splitter versions: `list_splitter_versions`, `publish_splitter_version`
* Check, list, cancel, or delete split runs: `get_split_run`, `list_split_runs`, `cancel_split_run`, `delete_split_run`
* Split up to 1,000 documents in one batch and check its status: `run_split_batch`, `get_split_batch`

### PDF Editing Tools

* Detect fillable fields in a PDF and generate an edit schema: `detect_form_fields`
* Fill a PDF from an edit schema and field values: `edit_pdf`
* Check or delete PDF edit runs: `get_edit_run`, `delete_edit_run`
* Check a form detection run: `get_form_detection_run`

### Workflow Tools

* Run a deployed or draft workflow: `run_workflow`
* Create, update, retrieve, and list workflows: `create_workflow`, `update_workflow`, `get_workflow`, `list_workflows`
* List workflow versions and deploy a version: `list_workflow_versions`, `deploy_workflow_version`
* Check, list, cancel, or delete workflow runs: `get_workflow_run`, `list_workflow_runs`, `cancel_workflow_run`, `delete_workflow_run`
* Run a workflow on up to 1,000 inputs in one batch: `run_workflow_batch`

### File Tools

* Request a browser upload and retrieve the uploaded files: `request_file_upload`, `get_file_upload`
* Retrieve file metadata and a temporary download URL, list files, or delete a file: `get_file`, `list_files`, `delete_file`

### Webhook Tools

* Create, list, update, or delete webhook endpoints: `create_webhook_endpoint`, `list_webhook_endpoints`, `update_webhook_endpoint`, `delete_webhook_endpoint`
* Create, list, update, or delete webhook subscriptions: `create_webhook_subscription`, `list_webhook_subscriptions`, `update_webhook_subscription`, `delete_webhook_subscription`

### Evaluation Tools

* Create and list evaluation sets: `create_evaluation_set`, `list_evaluation_sets`
* Add, list, update, or delete ground-truth evaluation items: `add_evaluation_items`, `list_evaluation_items`, `update_evaluation_item`, `delete_evaluation_item`
* Run an evaluation and check its results: `run_evaluation`, `get_evaluation_run`

Each tool includes instructions for choosing inputs, handling asynchronous work, and recovering from errors.

## Workspaces and environments

Every operation targets a specific workspace and environment. The agent must state both on every call, so nothing runs somewhere you didn't intend. `TEST` is the isolated [Test Environment](/general/test-environment-guide) (great for trying things out); `PRODUCTION` is live data. Resources are separate between the two: an extractor created in Test doesn't exist in Production.

OAuth connections can span multiple workspaces, with Test/Production chosen per workspace on the consent screen. To change access later, edit or re-approve the connection from your client; disconnecting and reconnecting re-runs consent.

## Uploading files from chat

Chat clients like Claude and ChatGPT don't expose your local files to remote servers. When you ask the agent to process a file that's only on your computer, it requests an **upload link**: you open the link, sign in to the Extend dashboard, drop your files, and click **Done**. The agent then picks the resulting files up and continues. The page shows who requested the upload and which workspace and environment the files will land in. Links expire after 15 minutes, and only members of the target workspace can use them.

If a document is already at a public URL, no upload link is needed.

## Troubleshooting

#### Authentication fails or tools return UNAUTHORIZED

Reconnect the server in your client to re-run the OAuth sign-in. Most clients have a reconnect or re-authenticate action on the server's settings entry; disconnecting and re-adding also works.

#### The agent can't find a resource I know exists

It's usually targeting the wrong place: resources are separated per workspace and per Test/Production environment. Ask the agent to check its granted workspaces and environments (the `get_me` tool) and to target where the resource actually lives.

#### Where do I look when a tool call fails?

Tool errors are structured: they tell the agent what was wrong, link to the relevant documentation page, and include a request ID. If the agent can't resolve an error, ask it for the request ID and message, and include them when contacting [support@extend.ai](mailto:support@extend.ai).

#### Should my coding agent use MCP, the CLI, or an SDK?

MCP is the best fit for chat and tool-calling clients. For agents writing durable integration code, use an [SDK](/sdks); for one-off shell-driven jobs, the [CLI](/cli). See the [Agent Quickstart](/agent-quickstart) for how to equip a coding agent.