Fundata MCP

Client Setup

Connect an AI client to the Fundata MCP server — Claude Desktop, ChatGPT, Copilot, or any host that takes a Bearer token (e.g. the Databricks built-in connector). They differ only in where you enter the server URL and your credentials; the server and tools are the same for all.

See also: Data dictionary · Solution architecture

Before you start — the same for every client
You need a Fundata agreement first. Access is governed by your organization's licensing agreement with Fundata. The MCP server holds no credentials of its own — it simply relays yours — so the same key & secret your organization already uses for the Fundata API are what grant access here, with the same entitlements. If you don't have credentials yet, arrange them with Fundata before connecting.
Server URL
https://mcp.fundataapi.com/mcp (production)
https://mcp.fundataapiuat.com/mcp (UAT / test)
Auth
Your own Fundata key & secret, sent as a header — any of: Authorization: Basic base64(key:secret); the pair X-Fundata-Key / X-Fundata-Secret; or Authorization: Bearer base64(key:secret) (Bearer also accepts a raw key:secret). Use production credentials with the production URL.
Transport
Streamable HTTP (not SSE). The server holds no credentials — it relays yours to Fundata per request.
Make the Basic value
printf '%s' 'YOUR-KEY:YOUR-SECRET' | base64
Keep credentials private. The examples below use placeholders (YOUR-KEY / YOUR-SECRET / <BASE64>). Put your real Fundata credentials only in your local config, never in shared docs or source control.

Claude Desktop mcp-remote

Claude Desktop reaches a remote MCP server through the local mcp-remote bridge, which injects the auth header. (The claude.ai web connector can't send a custom header, so it won't authenticate — use this config instead.)

  1. Prerequisite: Node.js installed (provides npx).
  2. Open the config file:
    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Windows: %APPDATA%\Claude\claude_desktop_config.json
  3. Add the server under mcpServers:
{
  "mcpServers": {
    "FundataMCP": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://mcp.fundataapi.com/mcp",
        "--header", "Authorization: Basic <BASE64>"
      ]
    }
  }
}
  1. Replace <BASE64> with your base64(key:secret) (keep the word Basic and the space; it's one argument).
  2. Fully quit Claude Desktop (Cmd+Q / right-click dock → Quit — not just closing the window) and reopen.
First launch runs npx to fetch mcp-remote, so allow a few extra seconds. If the tool list looks stale after any change, fully restart again.

ChatGPT connector

Added as a custom remote-MCP connector. Requires developer mode and a plan that allows custom connectors (Pro / Business / Enterprise).

  1. Settings → Connectors → add a custom connector / MCP server.
  2. Server URL: https://mcp.fundataapi.com/mcp — choose the HTTP / streamable transport (not SSE).
  3. Authentication — use one of:
    • Two custom headers: X-Fundata-Key = your key, X-Fundata-Secret = your secret.
    • A single header: Authorization = Basic <BASE64>.
  4. Save, then approve the connector's tools when prompted. They're all read-only, so calls are safe to allow.
If the connector only offers OAuth or No authentication (no place for a header), it can't pass Fundata credentials and every data call returns "No Fundata credentials supplied." A custom-header option is required.

Copilot VS Code · Studio

GitHub Copilot (VS Code / Visual Studio)

Add an MCP server in mcp.json (workspace .vscode/mcp.json or your user config) with type: http:

{
  "servers": {
    "FundataMCP": {
      "type": "http",
      "url": "https://mcp.fundataapi.com/mcp",
      "headers": { "Authorization": "Basic <BASE64>" }
    }
  }
}

Copilot Studio

Copilot Studio adds an MCP server as a custom connector defined by an OpenAPI (Swagger) spec. The transport is set by one property — x-ms-agentic-protocol: mcp-streamable-1.0 (our server is streamable-only; SSE fails at connect). Edit the connector's Swagger so it reads:

swagger: '2.0'
info: { title: Fundata MCP, version: '1.0' }
host: mcp.fundataapi.com
basePath: /
schemes: [https]
paths:
  /mcp:
    post:
      summary: Fundata MCP
      operationId: InvokeServer
      x-ms-agentic-protocol: mcp-streamable-1.0
      responses: { '200': { description: Success } }
securityDefinitions:
  api_key: { type: apiKey, in: header, name: Authorization }
security:
  - api_key: []

When you create the connection, enter the API key as the whole header value — Basic <BASE64> (keep the Basic prefix; if a scheme dropdown appears, pick custom/none so it isn't turned into Bearer).

Bearer-token clients Databricks & others

Some hosts — notably the Databricks built-in MCP connector — offer only OAuth or a plain Bearer token field, with nowhere to set a Basic or custom header. The OAuth choices need an authorization & token server this MCP server doesn't run, so choose the Bearer token option and put your credentials in it directly:

  1. Server URL: https://mcp.fundataapi.com/mcp
  2. Authentication: Bearer token
  3. Token: YOUR-KEY:YOUR-SECRET (raw), or the base64 of it (<BASE64>) — both are accepted.
  4. Leave any Authorization endpoint / Token endpoint and Client ID / Secret fields blank — those are for OAuth, which this server doesn't use.
The server treats Authorization: Bearer <base64(key:secret)> (or a raw key:secret) exactly like Basic — it's the same relay of your Fundata credentials. A genuine OAuth JWT is left untouched by this path, so it will coexist cleanly if OAuth is added later.

Verify & explore

Once connected, confirm credentials are flowing with a simple point query:

The server is self-describing — point the assistant at these to learn the data before querying: