Financial MCP server: give AI agents live market data

A financial MCP server is a Model Context Protocol server that exposes market data as tools an AI model can call: "latest quote for US:KO", "trading sessions in Tokyo today", "daily EURUSD bars for June". The model reads each tool's description and input schema, picks the one that answers the question, and gets structured JSON back instead of inventing a number from its training data.

TickerLayer runs one at https://mcp.tickerlayer.com/mcp. This guide covers how MCP works, the ten tools with real outputs, both ways to authenticate, when to build your own server, and the guardrails that keep an agent honest about market hours and stale data. For a client-by-client walkthrough, see how to connect Claude to live market data; for a working agent loop, see the AI trading bot tutorial.

What is MCP? Hosts, clients, servers and tools

MCP separates three roles. The host is the app you talk to: Claude, ChatGPT, an IDE or your own agent. Inside it, a client holds one connection to one server, and the server publishes tools, each with a name, a description and a JSON Schema for its inputs. Remote servers speak Streamable HTTP: JSON-RPC messages sent as HTTP POSTs, with responses that may arrive as a short server-sent event stream.

Tools beat letting the model write HTTP code, because the tool schema carries the knowledge the model would otherwise guess: that stocks need a country prefix (US:KO, never KO), that indices are their own asset class (US500, not US:US500), that timestamps are Unix milliseconds. The TickerLayer server also sends these conventions as server instructions during the handshake, so a well-behaved client reads them before the first call.

The ten TickerLayer MCP tools

Every tool is read-only: none of them places orders, changes an account or writes anything. Six of them take an asset_class of crypto, forex, stocks, indices, etfs, commodities or perpetuals (perpetuals need the Perpetuals plan). The calendar tools cover the classes that have trading hours; perpetual contracts trade around the clock.

Two behaviours are worth knowing before you write prompts. get_previous_close with interval: "1m" returns the most recently settled bar with its own bar_start and bar_end, so on a Monday morning it hands back the last minute of Friday's session rather than an empty result. And list_symbols filters the account's catalog by substring, which is how a model should turn "Coca-Cola" into US:KO instead of guessing a ticker.

get_snapshot is the workhorse: most "how is X doing" questions need exactly one call. Here is what it returned for Coca-Cola during the US pre-market on 28 September 2026:

{
  "symbol": "US:KO",
  "bid": 88.11,
  "ask": 88.2,
  "last_price": 88.16,1
  "last_timestamp": 1790592229876,2
  "last_size": 100,
  "prev_close": 87.81,3
  "change": 0.35,
  "change_percent": 0.39864
}

Connect a client with an API key or OAuth sign-in

There are two ways in. Clients that can send HTTP headers (Claude Code, Cursor, VS Code, Windsurf, custom agents) send your key as x-api-key, or as Authorization: Bearer with the same key. OAuth-capable clients such as ChatGPT developer-mode connectors need only the URL: the server implements the MCP authorization spec (OAuth 2.1 with discovery, PKCE, dynamic client registration and refresh tokens), so the client opens a TickerLayer sign-in and you approve access once.

claude mcp add --transport http tickerlayer https://mcp.tickerlayer.com/mcp \
  --header "x-api-key: YOUR_API_KEY"

{
  "mcpServers": {
    "tickerlayer": {
      "type": "http",
      "url": "https://mcp.tickerlayer.com/mcp",
      "headers": { "x-api-key": "YOUR_API_KEY" }
    }
  }
}

Example prompts and the tool calls behind them

The best way to judge a financial MCP server is to watch which tools a model picks. These prompts come from the MCP documentation; the right column is what a capable model calls.

Guardrails: market hours, freshness and honest failure

Connecting is the easy part. The hard part is time. Agents fail in three predictable ways: they describe a weekend price as live, they treat pre-market as the open market, and they paper over a failed tool call with a number from memory. All three are fixable, and the tools give you what you need.

{
  "asset": "stocks",
  "market": "US",
  "status": "pre_market",1
  "is_open": true,2
  "phase": "pre_market",
  "timezone": "America/New_York",
  "next_open": "2026-09-28T13:30:00.000Z",3
  "next_close": "2026-09-28T20:00:00.000Z"
}

Prompts steer; code enforces. If the answer feeds a decision, re-check status and freshness in your own code, as the AI trading bot tutorial does. The exchange calendar API guide covers sessions and holidays in depth, and bad ticks and stale prices covers freshness budgets.

Hosted financial MCP server or build your own

You rarely need to rebuild market-data tools, but you often need a few private ones: your positions, your risk limits, a spread calculation your desk trusts. MCP hosts can connect to several servers at once, so the practical architecture is layered: your small server for private logic, the hosted server for data.

If you do build an MCP server of your own, the Python MCP SDK keeps it short. This server adds one tool, spread in basis points, on top of the REST quote endpoint. It was tested with mcp 2.2 and httpx on Python 3.12:

"""A tiny MCP server with one private tool: spread in basis points."""
import os

import httpx
from mcp.server.mcpserver import MCPServer  # pip install "mcp>=2.2" httpx

API = "https://api.tickerlayer.com"
KEY = os.environ["TICKERLAYER_API_KEY"]

mcp = MCPServer("spread-tools")


@mcp.tool()
def spread_bps(asset_class: str, symbol: str) -> dict:
    """Bid-ask spread in basis points for one symbol, with the quote time.

    asset_class is crypto, forex, stocks, indices, etfs or commodities;
    stocks use COUNTRY:TICKER, for example US:KO.
    """
    resp = httpx.get(f"{API}/{asset_class}/quote/{symbol}",
                     headers={"x-api-key": KEY}, timeout=10)
    resp.raise_for_status()
    q = resp.json()
    bid, ask = float(q["bid"]), float(q["ask"])
    mid = (bid + ask) / 2
    return {"symbol": q["symbol"], "spread_bps": round((ask - bid) / mid * 10_000, 3),
            "timestamp": q["timestamp"]}


if __name__ == "__main__":
    mcp.run()  # stdio: the host launches this file as a subprocess

claude mcp add --transport stdio --env TICKERLAYER_API_KEY=YOUR_API_KEY \
  spread-tools -- python spread_server.py

# Tool result for spread_bps("stocks", "US:KO"), US pre-market:
# {"symbol": "US:KO", "spread_bps": 5.671, "timestamp": 1790592872094}

Tool design rules that make models pick the right call

Whatever you build, the model only sees names, descriptions and schemas. These are the rules the hosted server follows, and they carry over to any MCP server tutorial you start from:

• Few tools, uniform parameters. Ten tools with the same asset_class and symbol pair beat sixty per-asset tools. Models tend to choose worse as the list grows.
• Conventions in the description. Put the symbol format and a counter-example ("US:US500 is invalid, use indices US500") where the model reads it, not in a README it never sees.
• Errors as results, not crashes. Return a tool result flagged as an error with a plain sentence ("symbol not in catalog") so the model can recover or say so.
• Structured output. Return the JSON object as well as text, with units and timestamp fields named consistently, so the host can render it and the model can cite it.
• Read-only by annotation. Mark data tools read-only and non-destructive; hosts can use those hints to decide when to ask the user first.

Cost, limits and pay-per-call access

MCP access comes with every TickerLayer key, including the free tier, and consumes the same request quota. Paid feeds start at $49 a month on Individual plans with 250,000 REST calls; see pricing. If an agent should pay per call without an account at all, x402 pay-per-call payments cover 41 REST resources for a few cents each, settled in USDC.

MCP tools are request and response. For a price that updates on screen, use the WebSocket stream and let the agent read from your own cache. The MCP overview page lists every supported client.