> ## Documentation Index
> Fetch the complete documentation index at: https://developer.findity.com/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP

> Connect the Findity docs MCP server to Claude, Cursor, VS Code, and other AI tools to query the docs directly from your editor or chat.

The Findity Developer Portal docs are available as a Model Context Protocol (MCP) server, so AI tools like Claude, Cursor, VS Code, and ChatGPT can search and read the documentation directly from your workflow.

## What is MCP?

Model Context Protocol (MCP) is an open standard that lets AI applications securely access external data sources and tools. Connecting to the Findity docs MCP server gives your AI assistant:

* **Full-text search** across the Findity Developer Portal documentation
* **Direct page access** so answers cite the docs instead of guessing
* **In-context help** while you build integrations, without leaving your editor

## Server URL

The Findity docs MCP server is hosted automatically by Mintlify at the `/mcp` path of the docs site:

```text theme={"system"}
https://developer.findity.com/mcp
```

You do not need to run or self-host anything. There is no separate API key for the MCP server; it exposes the same public documentation available on the site.

## Connect from the contextual menu

The fastest way to connect is directly from any docs page:

**1. Open the contextual menu**

On any page, open the contextual menu next to the table of contents.

**2. Pick your tool**

Choose **Connect to Cursor** or **Connect to VS Code** to install the server in one click, or **Copy MCP server URL** / **Copy MCP install command** to configure it manually in another client.

## Connect manually

**Claude**

**1. Add a custom connector**

1. Go to the [Connectors](https://claude.ai/settings/connectors) page in Claude settings.
2. Click **Add custom connector**.
3. Enter a name (for example, `Findity Docs`) and the URL `https://developer.findity.com/mcp`.
4. Click **Add**.

**2. Use it in a chat**

In a Claude chat, click the attachments button (the plus icon) and select the Findity Docs connector. Claude can now search and read the Findity docs while answering your prompts.

**Claude Code**

Add the server with the Claude Code CLI:

```bash theme={"system"}
claude mcp add --transport http findity https://developer.findity.com/mcp
```

**Cursor**

**1. Open MCP settings**

Open the command palette with <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> on Windows), search for **Open MCP settings**, and click **Add custom MCP** to open `mcp.json`.

**2. Add the server**

```json theme={"system"}
{
  "mcpServers": {
    "findity": {
      "url": "https://developer.findity.com/mcp"
    }
  }
}
```

**VS Code**

Create a `.vscode/mcp.json` file in your project (or edit your user-level `mcp.json`) and add:

```json theme={"system"}
{
  "servers": {
    "findity": {
      "type": "http",
      "url": "https://developer.findity.com/mcp"
    }
  }
}
```

**Codex**

Add the server to `~/.codex/config.toml`:

```toml theme={"system"}
[mcp_servers.findity]
url = "https://developer.findity.com/mcp"
```

**Windsurf**

Add the server to `~/.codeium/windsurf/mcp_config.json`:

```json theme={"system"}
{
  "mcpServers": {
    "findity": {
      "serverUrl": "https://developer.findity.com/mcp"
    }
  }
}
```

## Test your connection

Once the server is connected, open a new chat in your AI tool and ask a question that requires the Findity docs, for example:

* "How do I authenticate a request to the Findity Developer Portal API?"
* "Show me an example of creating an expense with the Findity API."
* "Which endpoints are available for receipts?"

The assistant should call the MCP server, cite specific pages, and produce answers grounded in the live documentation.

## How to use the docs MCP

Once connected, the MCP server acts as a first-class source of truth your AI assistant can reach for during any task. Below are the workflows we see partners use most often.

### Answer product and API questions in chat

Instead of switching tabs to search the docs, ask your assistant directly. Because the MCP returns the actual page content, answers include specific endpoints, field names, and example payloads rather than paraphrased guesses.

> **Look up an endpoint**
>
> "What fields does the create receipt endpoint accept, and which are required?"

> **Clarify a concept**
>
> "Explain how expense categories map to accounts in Findity."

> **Find the right guide**
>
> "Which page in the Findity docs covers webhook signature verification?"

> **Compare options**
>
> "What is the difference between the sandbox and production environments?"

### Generate integration code

Pair the docs MCP with your editor's AI (Cursor, VS Code, Claude Code) to scaffold requests, and webhook handlers that match the current API contract.

**1. Describe the task**

Tell the assistant what you want to build and which language or framework you are working in. For example: "Write a TypeScript function that uploads a receipt image to the Findity API and returns the parsed expense."

**2. Reference the docs explicitly**

Ask the assistant to consult the Findity MCP for the exact request shape, required headers, and response schema before writing code. This keeps generated code aligned with the live docs.

**3. Iterate with follow-ups**

Follow up with prompts like "Add retry logic based on the rate-limit guidance in the docs" or "Handle every error code listed for this endpoint."

### Debug failing requests

When an integration behaves unexpectedly, paste the request, response, or error into your assistant and ask it to cross-check the docs.

* "This request returns `422 unprocessable_entity`. Look up the endpoint in the Findity docs and tell me which required field is missing."
* "Here is the webhook payload we received. Does it match the schema documented for `expense.created`?"
* "Our OAuth token exchange fails with `invalid_grant`. What does the Findity docs say the request should look like?"

### Draft internal documentation and runbooks

Use the MCP to keep your team's internal notes accurate:

* "Summarize the authentication flow from the Findity docs as a step-by-step runbook for our support team."
* "Create a checklist of everything a new integration needs before going live, based on the Findity onboarding guide."
* "List all rate limits documented for the Findity API in a table."

### Tips for better answers

> **Name the source explicitly**
>
> Prompts like "using the Findity docs MCP" or "consult the Findity documentation first" nudge the assistant to call the server instead of relying on training data.

> **Ask for citations**
>
> Request page titles or URLs alongside the answer so you can verify the source. If the assistant cannot cite a page, treat the answer as unverified.

> **Keep prompts specific**
>
> "How do I paginate the expenses endpoint?" produces a better MCP query than "How does the API work?" Specific questions map to specific pages.

> **Refresh when docs change**
>
> The MCP always serves the latest published docs. If an answer looks stale, ask the assistant to re-fetch the relevant page rather than relying on earlier chat context.