QuantOracle

The quantitative computation API for autonomous financial agents

63 deterministic, citation-verified calculators. 1,000 free calls/day. No signup.

quantoracle.dev  |  MCP Server  |  Free Tier  |  All 63 Endpoints  |  Agent Integration

Why QuantOracle?

Every financial agent needs math. QuantOracle is that math.

• 63 pure calculators across options, derivatives, risk, portfolio, statistics, crypto/DeFi, FX/macro, and TVM
• Zero dependencies on market data, accounts, or third-party APIs -- send numbers in, get numbers out
• Deterministic -- same inputs always produce the same outputs, so agents can cache, verify, and chain calls
• Citation-verified -- every formula tested against published textbook values (Hull, Wilmott, Bailey & Lopez de Prado)
• 120 accuracy benchmarks passing with analytical solutions
• Sub-millisecond response times on most endpoints
• Free tier -- 1,000 calls/IP/day, no API key, no signup, zero friction

QuantOracle is designed to be called repeatedly. An agent running a backtest might call 10+ endpoints per iteration. That's the model -- be the calculator agents reach for every time they need quant math.

Quick Start

# Call any endpoint -- no setup required
curl -X POST https://api.quantoracle.dev/v1/options/price \
  -H "Content-Type: application/json" \
  -d '{"S": 100, "K": 105, "T": 0.5, "r": 0.05, "sigma": 0.2, "type": "call"}'

{
  "call_price": 3.6862,
  "delta": 0.4467,
  "gamma": 0.0281,
  "theta": -0.0113,
  "vega": 0.2653,
  "rho": 0.1989,
  "d1": -0.1331,
  "d2": -0.2745,
  "ms": 0.04
}

Python

import requests

# Black-Scholes pricing
r = requests.post("https://api.quantoracle.dev/v1/options/price", json={
    "S": 100, "K": 105, "T": 0.5, "r": 0.05, "sigma": 0.2, "type": "call"
})
print(r.json()["call_price"])  # 3.6862

# Portfolio risk metrics (22 metrics from a returns series)
r = requests.post("https://api.quantoracle.dev/v1/risk/portfolio", json={
    "returns": [0.01, -0.005, 0.008, -0.003, 0.012, -0.001, 0.006, -0.009, 0.004, 0.002]
})
print(r.json()["sharpe_ratio"])  # Annualized Sharpe

# Kelly Criterion
r = requests.post("https://api.quantoracle.dev/v1/risk/kelly", json={
    "win_prob": 0.55, "win_loss_ratio": 1.5
})
print(r.json()["kelly_fraction"])  # Optimal bet size

# Monte Carlo simulation
r = requests.post("https://api.quantoracle.dev/v1/simulate/montecarlo", json={
    "S0": 10000, "mu": 0.08, "sigma": 0.15, "T": 10, "simulations": 1000
})
print(r.json()["median_terminal"])  # Median portfolio value at year 10

TypeScript

const res = await fetch("https://api.quantoracle.dev/v1/options/price", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ S: 100, K: 105, T: 0.5, r: 0.05, sigma: 0.2, type: "call" })
});
const { call_price, delta, gamma, vega } = await res.json();

Free Tier

1,000 free calls per IP per day. No signup. No API key. Just call the API.

Every response includes rate limit headers so agents can self-manage:

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 847
X-RateLimit-Reset: 2025-01-15T00:00:00Z

Check usage anytime:

curl https://api.quantoracle.dev/usage

After 1,000 calls, attach an x402 micropayment (USDC on Base) to continue:

MCP Server

QuantOracle is available as a native MCP server with 63 tools. Works with Claude Desktop, Cursor, Windsurf, and any MCP-compatible client.

Install via npm

npx quantoracle-mcp

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "quantoracle": {
      "command": "npx",
      "args": ["quantoracle-mcp"]
    }
  }
}

Remote MCP (Streamable HTTP)

Connect directly to the hosted server — no install required:

https://mcp.quantoracle.dev/mcp

Smithery

npx @smithery/cli mcp add https://server.smithery.ai/QuantOracle/quantoracle

Agent Integration

OpenAPI

Full OpenAPI 3.1 spec available at:

• Runtime: https://api.quantoracle.dev/openapi.json
• Swagger UI: https://api.quantoracle.dev/docs
• Static: openapi.json in this repo

Tool Discovery

# List all 63 tools with paths and pricing
curl https://api.quantoracle.dev/tools

# Health check
curl https://api.quantoracle.dev/health

MCP Manifest

MCP manifest at mcp/mcp.json for agent frameworks:

{
  "name": "quantoracle",
  "transport": { "type": "streamable-http", "url": "https://mcp.quantoracle.dev/mcp" },
  "free_tier": { "calls_per_day": 1000, "auth_required": false }
}

Full Endpoint Reference

Options (4 endpoints)

Derivatives (7 endpoints)

Risk (8 endpoints)

Indicators (6 endpoints)

Statistics (10 endpoints)

Portfolio (2 endpoints)

Fixed Income (4 endpoints)

Crypto / DeFi (7 endpoints)

FX / Macro (7 endpoints)

Time Value of Money (5 endpoints)

Simulation (1 endpoint)

Example: Agent Backtest Workflow

A typical agent backtest chains multiple QuantOracle calls per iteration:

1. /v1/indicators/technical    -- generate signals (SMA, RSI, MACD)
2. /v1/risk/position-size      -- size the trade (fixed fractional)
3. /v1/risk/transaction-cost   -- estimate execution costs
4. /v1/options/price            -- price the hedge (Black-Scholes)
5. /v1/risk/portfolio           -- compute running Sharpe, drawdown, VaR
6. /v1/stats/probabilistic-sharpe -- is the Sharpe statistically significant?
7. /v1/tvm/cagr                 -- compute CAGR of the equity curve

Each call is a pure calculator -- no state, no side effects, no API keys.

Self-Hosting

# Clone and run locally
git clone https://github.com/QuantOracledev/quantoracle.git
cd quantoracle
pip install fastapi uvicorn
uvicorn api.quantoracle:app --host 0.0.0.0 --port 8000

# Docker
docker compose up -d

# Docs at http://localhost:8000/docs

Accuracy

Every endpoint is tested against published analytical solutions:

• 120 citation-backed benchmarks (Hull, Wilmott, Bailey & Lopez de Prado, Goldman-Sosin-Gatto, Taylor, Fisher, Markowitz)
• 65 integration tests covering all 63 endpoints
• Pure Python math -- no numpy/scipy, zero native dependencies
• Deterministic: same inputs always produce the same outputs

Run the verification suite yourself:

python tests/accuracy_benchmarks.py https://api.quantoracle.dev

Architecture

quantoracle/
  api/quantoracle.py      -- FastAPI app, 63 endpoints, pure Python math
  worker/src/index.ts      -- Cloudflare Worker: rate limiting + x402 payments
  mcp/mcp.json             -- MCP manifest for agent discovery
  openapi.json             -- OpenAPI 3.0 spec
  tests/
    test_all.py            -- 65 integration tests
    accuracy_benchmarks.py -- 120 citation-backed accuracy tests

Stack: FastAPI + Pydantic | Cloudflare Workers + KV | x402 on Base (USDC)

License

MIT -- use QuantOracle however you want.