---
title: "Connect Claude, ChatGPT or Cursor to fund data with an MCP server"
description: "Set up the FundFacts MCP server in Claude, ChatGPT, Claude Code and Cursor: one URL, an account sign-in or an API key, and tools for fund lookup, comparison, look-through and overlap."
canonical: https://fundfactsapi.com/blog/fund-data-mcp-server-claude-chatgpt-cursor
published: 2026-09-18
updated: 2026-09-30
publisher: FundFacts API
---

# Connect Claude, ChatGPT or Cursor to fund data with an MCP server

> Set up the FundFacts MCP server in Claude, ChatGPT, Claude Code and Cursor: one URL, an account sign-in or an API key, and tools for fund lookup, comparison, look-through and overlap.

An MCP server gives an AI assistant tools it can call, and a fund data MCP server gives it the ability to look up any fund or ETF by ISIN, compare several, aggregate a portfolio and check holdings overlap, with the answers grounded in the fund's own published documents rather than the model's memory. FundFacts runs a remote Model Context Protocol server at `https://fundfactsapi.com/api/mcp` over Streamable HTTP; any client that supports remote servers with a bearer header (Claude Code, Cursor, Windsurf, or your own agent) can use it with one URL and an API key, and claude.ai, Claude Desktop and ChatGPT, whose connector forms have no header field, sign in with your FundFacts account instead.

> **In short** Server URL: `https://fundfactsapi.com/api/mcp`, transport: Streamable HTTP, auth: `Authorization: Bearer ffk_...`, or a sign-in with your FundFacts account in claude.ai, Claude Desktop, ChatGPT and Claude Code (a free account covers 5 lookups a month; the portfolio and overlap tools need Starter). Tools: `get_fund`, `search_funds`, `compare_funds`, `analyze_portfolio`, `fund_overlap`, plus `get_scpi` and `search_scpi` for French real-estate funds. Tools count against the same monthly requests as the REST endpoints; search is free. Stdio-only clients can bridge with `mcp-remote`.

## What the Model Context Protocol is, briefly

MCP is an open protocol that standardises how an AI application discovers and calls external tools. A server publishes a list of tools with JSON schemas; the client (Claude, Cursor, ChatGPT, an agent framework) shows those tools to the model, and when the model decides to call one, the client forwards the call and returns the result. The point is that the same server works in every client without per-client integration code. For fund data this replaces a pattern where each team wrote its own `getFund` function-calling wrapper, which [the LLM tooling post](https://fundfactsapi.com/blog/fund-data-for-ai-agents-and-llms) describes.

Remote MCP servers speak Streamable HTTP: the client POSTs JSON-RPC messages to one URL and can receive streamed responses. Authentication is a normal HTTP header, so a FundFacts API key works as the bearer token exactly as it does for the REST API.

## The seven tools

| Tool | What it does | Input | Cost |
| --- | --- | --- | --- |
| `get_fund` | Structured factsheet for one ISIN: key facts, TER, risk indicator, derived profile, holdings, breakdowns, returns, series, risk statistics, as-of date | `{ isin }` | 1 |
| `search_funds` | Find ISINs by name, issuer or ISIN prefix among loaded funds | `{ query, limit? }` | Free |
| `compare_funds` | Side-by-side table for several ISINs: category, TER, risk, size, distribution, 1/3/5-year annualised returns, volatility, Sharpe, max drawdown, top-10 concentration | `{ isins[], includeFullData? }` | 1 per ISIN |
| `analyze_portfolio` | Look-through of weighted positions: blended TER, weighted risk indicator, asset / sector / country / region / credit exposure, currency split, combined top holdings, each with coverage | `{ positions: [{ isin, weight }] }` | 1 per position |
| `fund_overlap` | Pairwise holdings overlap and shared positions for two or more ISINs | `{ isins[] }` | 1 per ISIN |
| `get_scpi` | Structured data for a French SCPI by slug, ISIN or name | `{ id }` | 1 |
| `search_scpi` | Find SCPIs by name, manager or ISIN prefix | `{ query, limit? }` | Free |

The tools behave exactly like the corresponding REST endpoints (`GET /funds/{isin}`, `GET /search`, `POST /funds`, `POST /portfolio`, `GET /overlap`, `GET /scpi/{id}`, `GET /scpi?q=`) and draw from the same 24-hour store, so a fund the API has served today is answered in well under a second. A fund nobody has requested before is loaded on demand, which can take a few minutes; the tool tells the model to ask again shortly rather than block. Tool descriptions carry the operational rules (no advice, quote the as-of date, one request per ISIN) so the model reads them without a system prompt.

## Claude Code

One command:

```bash
claude mcp add --transport http fundfacts https://fundfactsapi.com/api/mcp
```

Then run `/mcp` in a session and sign in with your FundFacts account. To use an API key instead, add `--header "Authorization: Bearer ffk_..."` to the command.

Or install the FundFacts plugin, which adds the server together with skills that tell Claude Code how to read the fund data: `/plugin marketplace add fundfactsapi/fundfacts-plugin`, then `/plugin install fundfacts@fundfacts`, then `/mcp` to sign in.

Once signed in, ask: "Compare IE00B4L5Y983 and IE00B3RBWM25 on fees, risk and top holdings, and tell me how much they overlap." Claude Code calls `compare_funds` and `fund_overlap` and answers from the results. If you are using Claude Code to build a product rather than to ask questions, the [coding-agent post](https://fundfactsapi.com/blog/build-fund-app-with-ai-coding-agent) covers the AI companion kit (an `AGENTS.md`, a Claude skill, a Cursor rule and the OpenAPI spec) that ships with every paid plan.

## Cursor and Windsurf

Both read an `mcp.json` (project-level `.cursor/mcp.json` or the global one in Cursor's settings). The remote-server entry is:

```json
{
  "mcpServers": {
    "fundfacts": {
      "url": "https://fundfactsapi.com/api/mcp",
      "headers": { "Authorization": "Bearer ffk_live_..." }
    }
  }
}
```

Enable the server in the MCP settings panel and the seven tools appear in the agent's tool list. A useful pattern while coding is to let the agent call `get_fund` on a real ISIN once, so it sees the actual payload shape rather than guessing field names.

## claude.ai and Claude Desktop

Both add remote servers through **Customize → Connectors → Add custom connector** (on Team and Enterprise an Owner adds it under **Organization settings → Connectors**; the Free plan allows one custom connector). The form takes a name and a URL and has no field for a custom header, so enter `https://fundfactsapi.com/api/mcp`, leave the advanced OAuth client fields empty and click Connect: a consent screen opens and you sign in with your FundFacts account (OAuth 2.1 with PKCE; the client registers itself). The connection then appears in the dashboard, where it can be disconnected, and counts against the same quota as an API key. Once the connector is enabled the seven tools are available in the conversation, and their results render as cards (fund, comparison, portfolio look-through, overlap, SCPI) next to Claude's answer, as they do in ChatGPT.

Claude Desktop's configuration file (`claude_desktop_config.json`) is for stdio servers, entries of the form "command + args". To register the FundFacts server there, bridge it with `mcp-remote`, which runs locally, forwards to the remote URL and adds the header:

```json
{
  "mcpServers": {
    "fundfacts": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://fundfactsapi.com/api/mcp", "--header", "Authorization: Bearer ffk_live_..."]
    }
  }
}
```

This is the configuration to use for any client whose config format is "command + args".

## ChatGPT

ChatGPT adds remote MCP servers in developer mode, available on Plus, Pro, Business, Enterprise and Edu, on the web. Turn it on under **Settings → Security and login → Developer mode**, then open **Plugins** (chatgpt.com/plugins) and click **+**. The form has no custom-header field and ChatGPT cannot send an API key, so enter a name and `https://fundfactsapi.com/api/mcp`, set Authentication to **OAuth** and click **Create**: ChatGPT opens the FundFacts consent screen, you sign in with your account, and that connection is what authenticates the calls. The seven tools then show up in the conversation, and a prompt such as "What does LU1681043599 hold and what does it cost?" triggers `get_fund`. In Business workspaces only admins and owners can use developer mode.

## Your own agent

If you are writing the agent, use an MCP client library and connect to the URL with the header. In TypeScript with the official SDK:

```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(new URL("https://fundfactsapi.com/api/mcp"), {
  requestInit: { headers: { Authorization: `Bearer ${process.env.FUNDFACTS_API_KEY}` } },
});
const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();           // get_fund, search_funds, compare_funds, …
const result = await client.callTool({ name: "get_fund", arguments: { isin: "IE00B4L5Y983" } });
// result.content[0].text is the JSON envelope: { isin, name, cached, generatedAt, data: { … } }
```

If you would rather generate tools from a spec, the [OpenAPI 3.1 document](https://fundfactsapi.com/openapi.json) describes the same endpoints and `/llms-full.txt` is the whole documentation in one file for a retrieval step.

## Prompts that work well

The tools are narrow on purpose (an ISIN in, a factsheet out), so the best prompts give the model an ISIN or a name it can search:

- "Search for 'core msci world' and get the factsheet of the accumulating USD share class."
- "Compare FR0010315770 with IE00B4L5Y983: fees, risk indicator, 3-year volatility, top holdings."
- "I hold 60% IE00B4L5Y983, 30% IE00B3RBWM25 and 10% LU1681043599. What is my country and sector exposure and my blended TER?"
- "How much do IE00B4L5Y983 and IE00B3RBWM25 overlap, and which shared holdings drive it?"
- "Get the SCPI 'perial-o2' and summarise its distribution rate history and occupancy."

Each answer should quote the `dataAsOf` date, which the tool returns; the tool descriptions ask the model to do so.

## Requests, keys and safety

- **Requests.** The MCP server draws on the same monthly requests as the REST API: Free 5, Starter 60 ($9.99), Pro 1,000 ($49), Scale 10,000 ($249); Enterprise is metered at $0.01 per request. See [pricing](https://fundfactsapi.com/pricing). Search tools are free; the others cost one request per fund found. `analyze_portfolio` and `fund_overlap` are available from Starter.
- **Keys.** The key in your MCP config is a real credential. Keep it in a config file that is not committed, and create a separate key per machine from the dashboard so one can be revoked without touching the others (Starter allows two keys, Pro and Scale ten).
- **Grounding.** The model only sees what the tool returns. It cannot fabricate a TER for a fund the server does not cover, because `get_fund` returns a clear not-found message and the description tells the model not to answer from memory. The [grounding and guardrails post](https://fundfactsapi.com/blog/fund-data-for-ai-agents-and-llms) covers the rules to add on your side for a customer-facing assistant, and the [AI fund assistant use case](https://fundfactsapi.com/use-cases/ai-fund-assistant) shows the product shape.

The full setup reference, including the OpenAPI spec and the companion kit, is on the [AI agents and MCP docs page](https://fundfactsapi.com/docs/ai-agents). A [free key](https://fundfactsapi.com/signup) is enough to try every tool.

## FAQ

### What is the URL of the FundFacts MCP server?

`https://fundfactsapi.com/api/mcp`, using the Streamable HTTP transport. Authenticate with `Authorization: Bearer ffk_...`, the same API key used for the REST endpoints.

### Which tools does the fund data MCP server expose?

`get_fund` (factsheet by ISIN), `search_funds` (find ISINs by name), `compare_funds` (side-by-side table), `analyze_portfolio` (look-through of weighted positions), `fund_overlap` (pairwise holdings overlap), and `get_scpi` / `search_scpi` for French SCPIs.

### Does the MCP server cost extra?

No. Tool calls draw on the plan's monthly requests exactly like REST calls: one request per fund found, search free. The Free plan's 5 lookups are enough to try get_fund and compare_funds on your own funds; analyze_portfolio and fund_overlap need Starter ($9.99).

### My client only supports stdio MCP servers. Can I still use it?

Yes. Run `npx -y mcp-remote https://fundfactsapi.com/api/mcp --header "Authorization: Bearer ffk_..."` as the server command; mcp-remote bridges stdio to the remote Streamable HTTP endpoint and adds the header.

### Can the model give investment advice through these tools?

The tools return data, not recommendations, and their descriptions instruct the model to describe rather than advise and to quote the as-of date. For a customer-facing assistant you should still enforce a no-advice rule in your own system prompt and code.

## About FundFacts API

FundFacts turns any fund or ETF ISIN into one dated factsheet (fees and KID costs, the 1–7 risk indicator, holdings, sector and country exposure, returns) read from the fund house's own documents: as a client-ready PDF under your firm's name for advisers and wealth managers, as JSON through its API for developers, or inside ChatGPT and Claude through its MCP server.

FundFacts works inside ChatGPT and Claude as a connector (a remote MCP server): ask about any fund or ETF by ISIN, ticker or name and the assistant answers from FundFacts' dated figures, fees, risk, holdings, exposure and returns, with fund cards, side-by-side comparisons, holdings overlap and portfolio look-through.

- Free API key, no card: https://fundfactsapi.com/signup
- Documentation: https://fundfactsapi.com/docs (OpenAPI: https://fundfactsapi.com/openapi.json)
- MCP server: https://fundfactsapi.com/api/mcp (set-up for every client: https://fundfactsapi.com/mcp-server)
- Pricing: https://fundfactsapi.com/pricing
- Site index for AI assistants: https://fundfactsapi.com/llms.txt
- Informational data, not investment advice.