Real-Time Financial Data for AI Agents via MCP

You're building an AI agent that needs stock quotes, crypto prices, or economic indicators. You could wire up Yahoo Finance, CoinGecko, and FRED APIs yourself — handle rate limits, parse inconsistent response formats, manage three sets of API keys, and hope nothing breaks when they change their schemas.

Or you could make one MCP tool call and get structured data back in seconds.

findata-mcp is a financial data MCP server that gives AI agents access to five data tools — stock quotes, company fundamentals, economic indicators, SEC filings, and crypto prices — through a single hosted endpoint with x402 micropayments.

Why MCP for Financial Data?

The Model Context Protocol is becoming the standard way AI agents discover and call external tools. Instead of hardcoding API integrations, your agent connects to an MCP server and gets a typed tool catalog it can reason about.

For financial data specifically, MCP solves three problems:

Data source abstraction — your agent doesn't need to know that stock quotes come from one API, economic data from another, and crypto from a third. It sees five tools with clear schemas.
Structured output — every response follows a consistent format. No more parsing HTML tables or guessing JSON shapes.
Payment built-in — x402 micropayments mean your agent can pay per call ($0.01) without API key management or monthly subscriptions.

The Five Tools

stock_quote

Real-time delayed equity quotes. Pass a ticker, get back price, change, volume, market cap.

from findata_mcp import FinDataClient

client = FinDataClient(
    private_key="0xYOUR_WALLET_KEY",
    network="base-mainnet"
)

quote = client.stock_quote("AAPL")
print(f"Apple: ${quote['price']} ({quote['change_percent']}%)")

company_fundamentals

Market cap, P/E ratio, EPS, dividend yield, sector classification — the numbers you need for valuation.

fundamentals = client.company_fundamentals("NVDA")
print(f"NVIDIA P/E: {fundamentals['pe_ratio']}")
print(f"Market cap: ${fundamentals['market_cap']:,.0f}")

economic_indicator

FRED-backed macroeconomic data. GDP, unemployment, CPI, federal funds rate — 400+ series.

gdp = client.economic_indicator("GDP")
print(f"US GDP: ${gdp['value']}B ({gdp['date']})")

crypto_price

Cryptocurrency pricing with 24h change, volume, and market cap.

btc = client.crypto_price("bitcoin")
print(f"BTC: ${btc['price']:,.2f} (24h: {btc['change_24h']}%)")

sec_filing

SEC EDGAR filing retrieval. 10-K, 10-Q, 8-K — search by company or CIK.

filings = client.sec_filing("TSLA", filing_type="10-K")
for f in filings['filings']:
    print(f"{f['type']} filed {f['date']}: {f['url']}")

How Payment Works

FinData uses x402 micropayments on Base mainnet. Each tool call costs $0.01 in USDC — paid automatically by the client library.

The flow:

Your agent calls a tool
The client signs a USDC payment claim with your wallet key
The server verifies the payment on-chain and returns data
Invalid requests (bad ticker, malformed params) are rejected before payment

No API keys. No monthly bills. No rate limit tiers. Just pay per call.

from findata_mcp import FinDataClient

client = FinDataClient(
    private_key="0xYOUR_WALLET_KEY",
    network="base-mainnet"
)

# Each call costs $0.01 USDC on Base
quote = client.stock_quote("MSFT")

You need USDC on Base chain in your wallet. If you're using a test wallet, fund it on Base bridge.

Using with Claude Code

If you're using Claude Code or any MCP-compatible client, add the server to your config:

{
  "mcpServers": {
    "findata": {
      "command": "uvx",
      "args": ["findata-mcp"],
      "env": {
        "FINDATA_WALLET_PRIVATE_KEY": "0xYOUR_KEY",
        "FINDATA_NETWORK": "base-mainnet"
      }
    }
  }
}

Now Claude can call financial data tools directly during conversations:

"What's Apple's current P/E ratio compared to the sector average?"

Claude calls company_fundamentals("AAPL"), gets structured data, and answers with real numbers.

Using via Streamable HTTP (Direct MCP)

You can also connect directly to the hosted MCP endpoint without installing anything:

https://findata-mcp-production-1cd3.up.railway.app/mcp

This endpoint supports the MCP Streamable HTTP transport. Discovery calls (initialize, tools/list) are free — you only pay when calling tools.

Architecture: Why a Hosted Server?

FinData is split into two components:

Thin client (public, PyPI): MCP tool definitions + x402 payment signing. Zero data-fetching logic.
Backend server (private, hosted on Railway): All the actual work — API calls, data normalization, payment verification, caching.

This matters because the valuable part (data aggregation, source management, error handling) stays server-side. The client is just a typed proxy that signs payments. You get the benefit of a managed service without vendor lock-in on the protocol level — any MCP client can talk to it.