Connect Your AI Agent to
Evidence-Grade Compliance Data

3 MCP servers · 48 tools · OAuth 2.0 + PKCE · Connect in minutes

What is FeedOracle MCP?

FeedOracle provides 3 MCP servers with 48 tools that give AI agents access to evidence-grade financial and regulatory data:

Every response is cryptographically signed and timestamped. Transport integrity via HMAC-SHA256. Premium tiers get ECDSA ES256K evidence signatures and blockchain-anchored PDF reports.

Why connect?

If you're building AI agents that touch regulated financial markets, you need data that auditors accept — not just data that works.

Evidence-grade, not just data. Every data point has a provenance chain: source, timestamp, hash, signature. Your agent gets a verifiable claim with a cryptographic proof trail.

MiCA-first. The July 2026 MiCA enforcement deadline affects every EU-facing stablecoin and CASP. FeedOracle covers 18 MiCA articles across 105+ tokens. No other oracle does this.

Built for machines. MCP means your AI agent can query regulatory status, risk scores, and macro signals autonomously — and explain its reasoning with full citations.

Developer & Enterprise Paths

Quick Start: 4 Steps to Your First MCP Call

No account, no login, no dashboard required. Just 4 HTTP requests.

curl -X POST https://feedoracle.io/mcp/register \
  -H "Content-Type: application/json" \
  -d '{
    "redirect_uris": ["http://localhost:3000/callback"],
    "client_name": "My AI Agent",
    "grant_types": ["authorization_code", "refresh_token"]
  }'
# -> { "client_id": "abc-123", "client_secret": "fo_secret_...", ... }

# verifier = random 43 bytes, challenge = SHA256(verifier) base64url
curl -G "https://feedoracle.io/mcp/authorize" \
  --data-urlencode "response_type=code" \
  --data-urlencode "client_id=abc-123" \
  --data-urlencode "redirect_uri=http://localhost:3000/callback" \
  --data-urlencode "code_challenge=YOUR_CHALLENGE" \
  --data-urlencode "code_challenge_method=S256" \
  --data-urlencode "scope=mcp:read"
# -> 302 redirect with ?code=fo_code_...

curl -X POST https://feedoracle.io/mcp/token \
  -d "grant_type=authorization_code" \
  -d "code=fo_code_..." \
  -d "client_id=abc-123" \
  -d "client_secret=fo_secret_..." \
  -d "redirect_uri=http://localhost:3000/callback" \
  -d "code_verifier=YOUR_VERIFIER"
# -> { "access_token": "fo_at_...", "expires_in": 3600, "refresh_token": "fo_rt_..." }

from mcp import ClientSession
from mcp.client.sse import sse_client

async with sse_client(
    "https://feedoracle.io/mcp/sse",
    headers={"Authorization": "Bearer fo_at_..."}
) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        result = await session.call_tool("mica_status", {"token_symbol": "USDC"})

Plans & Pricing

Every OAuth client starts on Free. Upgrade when you need more calls, deeper tools, or signed reports.

Payment via Stripe (card) or USDC on Polygon. Tier changes apply instantly — no downtime, no re-registration.

Enterprise: Trust & Governance

Scopes & Tool Access

Scopes control which tools your client can call. Granted based on your tier.

OAuth Reference

Discovery

Auth Endpoints

Token Lifecycle

Auth Methods

Priority: Bearer > API Key > Anonymous. All three methods coexist. Existing integrations continue to work.

Code Examples

Python — Full Flow

import hashlib, base64, secrets, requests, asyncio, json
from mcp import ClientSession
from mcp.client.sse import sse_client

BASE = "https://feedoracle.io/mcp"

# 1. Register (one-time)
reg = requests.post(f"{BASE}/register", json={
    "redirect_uris": ["http://localhost:3000/cb"],
    "client_name": "My Trading Agent",
    "grant_types": ["authorization_code", "refresh_token"],
}).json()
CID, CS = reg["client_id"], reg["client_secret"]

# 2. PKCE
verifier = secrets.token_urlsafe(43)
challenge = base64.urlsafe_b64encode(
    hashlib.sha256(verifier.encode()).digest()
).rstrip(b"=").decode()

# 3. Authorize
r = requests.get(f"{BASE}/authorize", params={
    "response_type": "code", "client_id": CID,
    "redirect_uri": "http://localhost:3000/cb",
    "code_challenge": challenge, "code_challenge_method": "S256",
    "scope": "mcp:read",
}, allow_redirects=False)
code = r.headers["location"].split("code=")[1].split("&")[0]

# 4. Token
tokens = requests.post(f"{BASE}/token", data={
    "grant_type": "authorization_code", "code": code,
    "client_id": CID, "client_secret": CS,
    "redirect_uri": "http://localhost:3000/cb",
    "code_verifier": verifier,
}).json()

# 5. Query
async def query():
    hdrs = {"Authorization": f"Bearer {tokens['access_token']}"}
    async with sse_client(f"{BASE}/sse", headers=hdrs) as (r, w):
        async with ClientSession(r, w) as s:
            await s.initialize()
            return await s.call_tool("mica_status", {"token_symbol": "USDC"})

print(asyncio.run(query()))

Claude Desktop

{
  "mcpServers": {
    "feedoracle-compliance": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://feedoracle.io/mcp/sse"]
    },
    "feedoracle-macro": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://feedoracle.io/mcp/macro/sse"]
    },
    "feedoracle-risk": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://feedoracle.io/mcp/risk/sse"]
    }
  }
}

← Documentation · MCP Overview · Pricing · Uptime Status