MCP ready

MCP Server — connect AI to interest rate data

Give Claude, Cursor, or any MCP-compatible agent live access to central bank policy rates, interbank benchmarks, and treasury yields for 50+ countries — no scraping, no stale training data.

What is MCP, and why does it matter?

The Model Context Protocol (MCP) lets AI assistants call external tools and fetch live data mid-conversation, instead of relying on outdated training data. Point an MCP-compatible agent at our endpoint and it can pull real interest rate data — current or historical — the moment you ask.

Example: ask Claude "What's the spread between SOFR and EURIBOR 3M right now?" and it calls the latest tool automatically — no manual API calls, no copy-pasting JSON.

Live data

50+ countries, updated on each institution's own publication schedule.

Natural language

Ask questions in plain English — the agent maps them to the right tool.

Same API quota

MCP calls use your existing plan. One tool call = one API request.

Available MCP tools

Seven tools, one per REST endpoint — see the full API reference for parameters.

symbols

List all 44+ available rate symbols with metadata (category, country, currency, frequency). Use this first to discover valid symbol names.

latest

Most recent value for one or more symbols, with the exact observation date and currency per symbol.

historical

Value of one or more symbols on a specific past date, with an optional `nearest` fallback for daily symbols on weekends/holidays.

timeseries

Full history of one or more symbols between two dates, keyed by observation date — ideal for charting.

fluctuation

Start/end value, absolute and percentage change, and min/max over a date range, for one or more symbols.

ohlc

Open/High/Low/Close aggregates over weekly, monthly, or quarterly periods, computed from daily observations.

convert

Compare total interest cost of a loan amount under two different rate symbols over a given term.

Getting started

One endpoint for every client. Authenticate with your API key as a header or query parameter — no separate MCP credential to manage.

MCP endpoint

https://mcp.interestratesapi.com/mcp

Send your API key one of three ways:

  • Authorization: Bearer YOUR_API_KEY
  • X-API-Key: YOUR_API_KEY
  • ?apikey=YOUR_API_KEY on the URL itself — for clients whose config only accepts a plain URL

Need a key first? Register for a free trial, then grab it from your dashboard.

Connect Claude Desktop / claude.ai

Add a custom connector with the endpoint URL and your key embedded as a query parameter — the simplest option for clients that only take a plain URL.

claude_desktop_config.json
{
  "mcpServers": {
    "interestratesapi": {
      "url": "https://mcp.interestratesapi.com/mcp?apikey=YOUR_API_KEY"
    }
  }
}

On claude.ai, add it under Settings → Connectors → Add custom connector with the same URL (including ?apikey=) as the remote server address. Restart Claude Desktop after editing the config file.

Connect Claude Code (CLI)

Add the server with your key as an auth header, from any terminal:

bash
claude mcp add --transport http interestratesapi https://mcp.interestratesapi.com/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

Then, inside a Claude Code session, run /mcp to confirm it's connected, or claude mcp list from the terminal.

Connect Cursor

Add to ~/.cursor/mcp.json (or .cursor/mcp.json in a project for a project-only setup):

mcp.json
{
  "mcpServers": {
    "interestratesapi": {
      "url": "https://mcp.interestratesapi.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Save, then fully quit and reopen Cursor. Try: "What's the current Fed Funds Rate?"

Python example

A minimal client that calls the latest tool over MCP's JSON-RPC 2.0 protocol.

get_latest_rate.py
import httpx
import json
import asyncio

MCP_SERVER_URL = "https://mcp.interestratesapi.com/mcp"
API_KEY = "YOUR_API_KEY"

async def call_mcp_tool(tool_name: str, arguments: dict):
    async with httpx.AsyncClient(timeout=30) as client:
        init_response = await client.post(
            MCP_SERVER_URL,
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={
                "jsonrpc": "2.0",
                "id": "1",
                "method": "initialize",
                "params": {
                    "protocolVersion": "2024-11-05",
                    "capabilities": {},
                    "clientInfo": {"name": "PythonClient", "version": "1.0.0"},
                },
            },
        )
        session_id = init_response.headers.get("Mcp-Session-Id")

        response = await client.post(
            MCP_SERVER_URL,
            headers={"Authorization": f"Bearer {API_KEY}", "Mcp-Session-Id": session_id},
            json={
                "jsonrpc": "2.0",
                "id": "2",
                "method": "tools/call",
                "params": {"name": tool_name, "arguments": arguments},
            },
        )
        return response.json()

async def main():
    result = await call_mcp_tool("latest", {"symbols": "FED_FUNDS,SOFR"})
    print(json.dumps(result, indent=2))

asyncio.run(main())

Frequently asked questions

Send your API key as an Authorization: Bearer YOUR_API_KEY header, an X-API-Key header, or a ?apikey= query parameter on the MCP URL — whichever your client supports. No separate signup: it is the same key you use for the REST API.
Yes. Each MCP tool call is one API request and counts toward your plan's monthly quota, the same as a REST call.
Yes — call POST /oauth/token with grant_type=client_credentials to exchange your key for a short-lived bearer token. See /auth.md for details. This is optional — most agents just use the API key directly.
Yes. Any client that speaks the Model Context Protocol (JSON-RPC 2.0 over HTTP) can connect — Claude, Cursor, custom Python/Node clients, and anything else that supports remote MCP servers.