Try it without writing code
12 free interactive calculators backed by the same API are live at quantoracle.dev — no signup, no API key:
- Black-Scholes Option Pricing — call/put price + full Greeks
- American Option (Binomial Tree) — early exercise + dividends
- Options Profit Calculator — multi-leg payoff diagrams
- Implied Volatility — Newton-Raphson IV solver
- Monte Carlo Simulation — portfolio + retirement scenarios
- Kelly Criterion — full / half / quarter-Kelly sizing
- Position Size — fixed-fractional risk
- Value at Risk (VaR) — parametric VaR + CVaR
- Sharpe Ratio — with 95% confidence interval
- CAGR — compound annual growth rate + projections
- Crypto Liquidation Price — long/short, any leverage
- Impermanent Loss — Uniswap v2 + v3
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
- 10 composite workflows that bundle 5-15 calculator calls (backtest strategies, rebalance planning, options strategy selection, hedging recommendations, full risk analysis, pairs signals, and more)
- Zero dependencies for the 73 calculators + composites -- no market data, accounts, or third-party APIs; send numbers in, get numbers out
- QuantOracle Live (new) -- a separate paid tier that brings the data: fresh crypto volatility (
/v1/live/volatility) and perp funding rates (/v1/live/funding-rates). We fetch the live market data and run the math, so your agent doesn't have to. 20 free calls/IP/day to evaluate, then pay-per-call via x402. - QuantOracle Watch (new) -- 24/7 position monitoring: register a crypto perp position once and get HMAC-signed webhooks on funding-adjusted liquidation distance, funding flips, and vol-regime changes — re-checked every 60 seconds. Free 48h trial; $5 per position per 30 days via x402.
- Deterministic -- the calculators always produce the same outputs for the same inputs, 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
- Fast -- sub-millisecond to 70ms compute time per call
- 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.
Why not just let the LLM do the math?
| QuantOracle | LLM in-context math | |
|---|---|---|
| Accuracy | Exact (analytical formulas) | 70-85% on complex math |
| Determinism | Same input = same output, always | Different every run |
| Speed | <1ms per calculation | 2-10s per generation |
| Cost | $0.002-0.015 per call | $0.01-0.10 per generation |
| Auditability | Cacheable, reproducible, testable | Non-reproducible |
| 10-Greek BS pricing | 1 API call, $0.005 | ~500 tokens, frequently wrong on gamma/vanna |
📓 LangChain cookbook
Build a 25-line LangChain agent that answers concrete quant questions — "I'm long $100k of NVDA at $185, how should I hedge?" — with deterministic, reproducible math:
integrations/langchain/cookbook/quantoracle_risk_analyst.ipynb
Runs in 30 seconds, ~$0.001 in OpenAI tokens, free for QuantOracle's individual calculators. The hedging-recommend composite shown above is $0.04 in USDC via x402.
Add QuantOracle to Your Agent
Drop this into your agent's system prompt:
You have access to QuantOracle -- 63 deterministic financial calculators + 10 composite workflows at https://api.quantoracle.dev.
Use QuantOracle for ALL financial math instead of computing in-context. It is faster, cheaper, and exact.
Send POST requests with JSON. No API key needed (1,000 free calls/day).
Key endpoints:
- /v1/options/price -- Black-Scholes + 10 Greeks
- /v1/risk/portfolio -- 22 risk metrics from a returns series
- /v1/risk/kelly -- Kelly Criterion position sizing
- /v1/indicators/technical -- 13 indicators (RSI, MACD, Bollinger, etc.)
- /v1/simulate/montecarlo -- Monte Carlo simulation (up to 5,000 paths)
- /v1/stats/hurst-exponent -- Mean-reversion detection
- /v1/fixed-income/bond -- Bond pricing + duration + convexity
Paid-only composites (recommended for common agent workflows):
- /v1/backtest/strategy -- Run SMA/RSI/momentum/Bollinger backtest (Sharpe, drawdown, trades)
- /v1/portfolio/rebalance-plan -- Generate trades to hit target weights with cost estimate
- /v1/options/strategy-optimizer -- Rank options strategies given outlook + vol view
- /v1/hedging/recommend -- Cheapest effective hedge for a position
- /v1/risk/full-analysis, /v1/trade/evaluate, /v1/portfolio/health, /v1/pairs/signal, /v1/options/spread-scan, /v1/indicators/regime-classify
Full endpoint list: https://api.quantoracle.dev/tools
OpenAPI spec: https://api.quantoracle.dev/openapi.json
x402 discovery: https://api.quantoracle.dev/.well-known/x402 (advertises Base and Solana USDC)
Discovery URLs (for agent frameworks and crawlers)
| Format | URL |
|---|---|
| OpenAPI spec | https://api.quantoracle.dev/openapi.json |
| Tool listing | https://api.quantoracle.dev/tools |
| MCP endpoint | npx quantoracle-mcp |
| AI Plugin | https://api.quantoracle.dev/.well-known/ai-plugin.json |
| Server card | https://mcp.quantoracle.dev/.well-known/mcp/server-card.json |
| Swagger docs | https://api.quantoracle.dev/docs |
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"}'
{
"price": 4.5817,
"intrinsic": 0,
"time_value": 4.5817,
"breakeven": 109.5817,
"prob_itm": 0.4056,
"greeks": {
"delta": 0.4612,
"gamma": 0.0281,
"theta": -0.0211,
"vega": 0.2808,
"rho": 0.2077,
"vanna": 0.0047,
"charm": -0.0006,
"volga": 0.0327,
"speed": -0.0001
},
"d1": -0.0975,
"d2": -0.2389,
"ms": 12.4
}
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()["price"]) # 4.5817
# 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()["risk"]["sharpe"]) # Annualized Sharpe
# Kelly Criterion
r = requests.post("https://api.quantoracle.dev/v1/risk/kelly", json={
"mode": "discrete", "win_rate": 0.55, "avg_win": 1.5, "avg_loss": 1.0
})
print(r.json()["half_kelly"]) # Recommended bet fraction
# Monte Carlo simulation
r = requests.post("https://api.quantoracle.dev/v1/simulate/montecarlo", json={
"initial_value": 100000, "annual_return": 0.08, "annual_vol": 0.15, "years": 10, "simulations": 1000
})
print(r.json()["terminal"]["median"]) # 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 { price, greeks } = await res.json();
const { delta, gamma, vega } = greeks;
CLI
All 63 calculators + 10 composites in your terminal. Zero dependencies.
npm install -g quantoracle-cli
Or run without installing:
npx quantoracle-cli bs --spot 185 --strike 190 --expiry 0.25 --vol 0.25
QuantOracle · Black-Scholes (call)
────────────────────────────────────
Price $8.02
Intrinsic $0.00
Time Value $8.02
Breakeven $198.02
Prob ITM 43.0%
Greeks
────────────────────────────────────
Delta 0.4797
Gamma 0.0172
Theta -0.0615/day
Vega 0.3685
────────────────────────────────────
⏱ 0.05ms · api.quantoracle.dev
# Kelly criterion
qo kelly --win-rate 0.55 --avg-win 120 --avg-loss 100
# Monte Carlo
qo mc --value 80000 --return 0.10 --vol 0.18 --years 2
# JSON output for scripting
qo bs --spot 185 --strike 190 --expiry 0.25 --vol 0.25 --json | jq '.greeks.delta'
# Data from file
qo risk portfolio --returns @returns.txt
# All commands
qo help
Free Tier
1,000 free calls per IP per day. No signup. No API key. Just call the API.
| Free | Paid (x402) | |
|---|---|---|
| Calls | 1,000/day | Unlimited |
| Auth | None | x402 micropayment header |
| Calculators | All 63 | All 63 |
| Composite workflows | None (paid-only) | All 10 |
| Live data tier | 20 calls/day | Pay-per-call |
| Watch monitoring | Free 48h trial (1 per IP / 30d) | $5 per position / 30 days |
| Rate headers | Yes | Yes |
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, the API returns 402 Payment Required with an x402 payment header. Any x402-compatible agent automatically pays and continues:
HTTP/1.1 402 Payment Required
PAYMENT-REQUIRED: <base64-encoded payment instructions>
| Tier | Price | Endpoints |
|---|---|---|
| Simple | $0.002 | Z-score, APY/APR, Fibonacci, Bollinger, ATR, Taylor rule, inflation, real yield, PV, FV, NPV, CAGR, normal distribution, Sharpe ratio, liquidation price, put-call parity |
| Medium | $0.005 | Black-Scholes, implied vol, Kelly, position sizing, drawdown, regime, crossover, bond amortization, carry trade, IRP, PPP, funding rate, slippage, vesting, rebalance, IRR, realized vol, PSR, transaction cost |
| Complex | $0.008 | Portfolio risk, binomial tree, barrier/Asian/lookback options, credit spread, VaR, stress test, regression, cointegration, Hurst, distribution fit, risk parity |
| Heavy | $0.015 | Monte Carlo, GARCH, portfolio optimization, option chain analysis, vol surface, yield curve, correlation matrix |
| Composite | $0.015-0.10 | Backtest strategy, spread scan, rebalance plan, options strategy optimizer, hedging recommend, full risk analysis, trade evaluate, portfolio health, pairs signal, regime classify (paid-only, no free tier) |
Batch Endpoint
Run up to 100 computations in a single HTTP request. One round trip instead of 100.
curl -X POST https://api.quantoracle.dev/v1/batch \
-H "Content-Type: application/json" \
-d '{
"requests": [
{"endpoint": "options/price", "params": {"S": 100, "K": 105, "T": 0.25, "r": 0.05, "sigma": 0.2}},
{"endpoint": "stats/zscore", "params": {"series": [10, 12, 14, 11, 13, 15]}},
{"endpoint": "tvm/cagr", "params": {"start_value": 100, "end_value": 150, "years": 3}}
]
}'
Returns all results in one response with the total price:
{
"batch_size": 3,
"total_price_usdc": 0.009,
"results": [
{"endpoint": "options/price", "status": 200, "data": {"price": 2.4779, "greeks": {"delta": 0.377, "..."}}},
{"endpoint": "stats/zscore", "status": 200, "data": {"mean": 12.5, "std_dev": 1.87, "..."}},
{"endpoint": "tvm/cagr", "status": 200, "data": {"cagr": 0.1447, "doubling_time_years": 5.13, "..."}}
],
"ms": 42.13
}
| Free | Paid | |
|---|---|---|
| Batch calls | 1 trial (ever) | Unlimited |
| Max per batch | 100 | 100 |
| Price | Free | Sum of individual endpoint prices |
Batch pricing is the sum of the individual endpoint prices — no markup. You pay for the computations, the speed is free.
QuantOracle Live — fresh market data + compute
Every endpoint above is pure math on inputs you supply — the 73 calculators have zero data dependencies, which is what makes them deterministic and cacheable. QuantOracle Live is the one tier that brings the data: you pass a ticker, the API fetches fresh market data and runs the math, so your agent never has to source or maintain a data feed.
| Endpoint | Description | Price |
|---|---|---|
POST /v1/live/volatility | Realized volatility (7d/30d/90d) + regime for a crypto asset, from fresh daily candles | $0.01 |
POST /v1/live/funding-rates | Current perpetual funding rate + annualized carry for a crypto asset | $0.005 |
curl -X POST https://api.quantoracle.dev/v1/live/volatility \
-H "Content-Type: application/json" \
-d '{"asset":"BTC"}'
# → {"asset":"BTC","spot":61728.7,"realized_vol_7d":0.4534,
# "realized_vol_30d":0.3108,"realized_vol_90d":0.3157,"regime":"NORMAL",
# "as_of_age_seconds":0,"stale":false,"source":"kraken", ...}
Pricing: the Live tier is paid from the first call — it is not part of the 1,000/day calculator free tier (the value is the fresh data + pipeline, which you can't replicate with a local library). You get 20 free calls per IP per day to evaluate, then it settles per-call via x402 (USDC on Base or Solana). You pay for freshness, not arithmetic.
Results are cached server-side (volatility ~5 min, funding ~1 min); if an upstream feed is briefly unavailable, the API serves the last good value flagged stale: true, with as_of_age_seconds telling you how fresh the answer is.
QuantOracle Watch — 24/7 position monitoring
Most monitoring agents rebuild the same loop: poll crypto/liquidation-price + risk/var-parametric on a timer, all day. Watch replaces the loop — register a crypto perp position once and an isolated watcher re-evaluates it every ~60 seconds: funding-adjusted liquidation distance (warn/critical bands with hysteresis), funding-rate sign flips, hourly vol-regime changes, and expiry warnings. Alerts fire as HMAC-signed webhooks (X-QO-Signature, key = your monitor token) and are recorded server-side, so the trial needs zero infrastructure — just poll.
| Endpoint | Description | Price |
|---|---|---|
POST /v1/watch/trial | Free 48-hour monitor — one per IP per 30 days | Free |
POST /v1/watch/position | Register a position for 30 days of monitoring | $5.00 |
POST /v1/watch/extend | +30 days (also upgrades a trial; body: {monitor_id, token}) | $5.00 |
PATCH /v1/watch/{id} | Update position params after you add margin / resize / move it | Free |
GET /v1/watch/{id} | Live status + alert history (token auth) | Free |
DELETE /v1/watch/{id} | Cancel | Free |
curl -X POST https://api.quantoracle.dev/v1/watch/trial \
-H "Content-Type: application/json" \
-d '{"asset":"BTC","direction":"long","entry_price":62000,
"position_size":5000,"collateral":1000}'
# → {"monitor_id":"w_...","token":"...","tier":"trial","status":"active",
# "liquidation_price":49910,"distance_pct":19.5,
# "status_url":"https://api.quantoracle.dev/v1/watch/w_...", ...}
No exchange keys, no custody, no execution — Watch reads public market data and sends webhooks, so the worst failure mode is a missed alert (the watcher heartbeat is published in /health as watcher_heartbeat_age_s). Webhook targets are SSRF-guarded and deliveries retried. The economics: a DIY loop polling the same math once a minute past the free tier costs ~$7.20/day in per-call fees vs $5 per 30 days. Full walkthrough: quantoracle.dev/writing/crypto-liquidation-alerts-for-agents.
x402 Payments
QuantOracle uses the x402 protocol for pay-per-call micropayments. When an agent exhausts its free tier (or calls a paid-only composite), the API returns a standard 402 response with payment instructions advertising both Base and Solana. x402-compatible agents (Coinbase AgentKit, AgentCash, OpenClaw, etc.) handle the rest automatically:
- Agent calls endpoint, gets
402withPAYMENT-REQUIREDheader listing accepted networks - Agent signs a gasless USDC transfer authorization on Base (EIP-3009) or Solana
- Agent resends request with
PAYMENT-SIGNATUREheader - Server verifies via CDP facilitator, serves the response, settles on-chain
No API keys. No subscriptions. No accounts. Just math and micropayments.
Supported Networks
| Network | Asset | Gas | Best for |
|---|---|---|---|
Base mainnet (eip155:8453) | USDC (0x8335...) | ~$0.005/tx | EVM agents, Coinbase tooling, LangChain, Base ecosystem |
Solana mainnet (solana:5eykt4...) | USDC (EPjFWdd5...) | ~$0.0002/tx (CDP fee-payer) | Solana Agent Kit, Eliza, high-frequency bots |
- Settlement: Via Coinbase Developer Platform facilitator (
api.cdp.coinbase.com/platform/v2/x402) - Base wallet:
0xC94f5F33ae446a50Ce31157db81253BfddFE2af6 - Solana wallet:
9biztrXscReJ3Wi8EfkD2gL3WXzYUmzTEohD26Bxp39u - Discovery:
https://api.quantoracle.dev/.well-known/x402(returns both chains for every endpoint)
Test it with AgentCash
npx agentcash@latest onboard
# Fund the Base or Solana wallet shown, then:
npx agentcash fetch https://api.quantoracle.dev/v1/risk/full-analysis \
-m POST --payment-network solana \
--body '{"returns":[0.01,-0.02,0.03,0.005,-0.01,0.02,-0.015,0.025,0.01,-0.005,0.015]}'
MCP Server
QuantOracle is available as a native MCP server with 80 tools (63 calculators + 11 composites + 2 live market-data endpoints + 3 QuantOracle Watch monitoring tools + batch). Works with Claude Desktop, Cursor, Windsurf, Smithery, and any MCP-compatible client.
Install via npm
npx quantoracle-mcp
Claude Desktop / Claude Code
Add as a connector in Settings, or add to claude_desktop_config.json:
{
"mcpServers": {
"quantoracle": {
"url": "https://mcp.quantoracle.dev/mcp"
}
}
}
Or run locally via npx:
{
"mcpServers": {
"quantoracle": {
"command": "npx",
"args": ["-y", "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
OpenClaw / ClawHub
clawhub install quantoracle
Integrations
QuantOracle is available across multiple agent ecosystems:
| Platform | How to connect |
|---|---|
| Claude Desktop / Claude Code | Connector URL: https://mcp.quantoracle.dev/mcp |
| Cursor / Windsurf | MCP config: npx quantoracle-mcp |
| Smithery | npx @smithery/cli mcp add QuantOracle/quantoracle |
| OpenClaw / ClawHub | clawhub install quantoracle |
| CLI | npm install -g quantoracle-cli or npx quantoracle-cli |
| Glama | glama.ai/mcp/servers/QuantOracledev/quantoracle |
| npm (MCP) | npx quantoracle-mcp |
| x402 ecosystem | x402.org/ecosystem |
| ChatGPT GPT | QuantOracle GPT |
| LangChain | pip install langchain-quantoracle |
| AgentCash | npx agentcash fetch https://api.quantoracle.dev/v1/... |
| x402scan | Server page — Base + Solana |
| REST API | https://api.quantoracle.dev/v1/... |
| OpenAPI spec | https://api.quantoracle.dev/openapi.json |
| Swagger UI | https://api.quantoracle.dev/docs |
Tool Discovery
# List all tools (63 calculators + 10 composites) with paths and pricing
curl https://api.quantoracle.dev/tools
# x402 discovery (advertises Base + Solana for every endpoint)
curl https://api.quantoracle.dev/.well-known/x402
# Health check
curl https://api.quantoracle.dev/health
# Usage check
curl https://api.quantoracle.dev/usage
# MCP server card
curl https://mcp.quantoracle.dev/.well-known/mcp/server-card.json
Full Endpoint Reference
Options (4 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/options/price | Black-Scholes pricing with 10 Greeks (delta through color) | $0.005 |
POST /v1/options/implied-vol | Newton-Raphson implied volatility solver | $0.005 |
POST /v1/options/strategy | Multi-leg options strategy P&L, breakevens, max profit/loss | $0.008 |
POST /v1/options/payoff-diagram | Multi-leg options payoff diagram data generation | $0.005 |
Derivatives (7 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/derivatives/binomial-tree | CRR binomial tree pricing for American and European options | $0.008 |
POST /v1/derivatives/barrier-option | Barrier option pricing using analytical formulas | $0.008 |
POST /v1/derivatives/asian-option | Asian option pricing: geometric closed-form or arithmetic approximation | $0.008 |
POST /v1/derivatives/lookback-option | Lookback option pricing (floating/fixed strike, Goldman-Sosin-Gatto) | $0.008 |
POST /v1/derivatives/option-chain-analysis | Option chain analytics: skew, max pain, put-call ratios | $0.015 |
POST /v1/derivatives/put-call-parity | Put-call parity check and arbitrage detection | $0.002 |
POST /v1/derivatives/volatility-surface | Build implied volatility surface from market data | $0.015 |
Risk (8 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/risk/portfolio | 22 risk metrics: Sharpe, Sortino, Calmar, Omega, VaR, CVaR, drawdown | $0.008 |
POST /v1/risk/kelly | Kelly Criterion: discrete (win/loss) or continuous (returns series) | $0.005 |
POST /v1/risk/position-size | Fixed fractional position sizing with risk/reward targets | $0.005 |
POST /v1/risk/drawdown | Drawdown decomposition with underwater curve | $0.005 |
POST /v1/risk/correlation | N x N correlation and covariance matrices from return series | $0.008 |
POST /v1/risk/var-parametric | Parametric Value-at-Risk and Conditional VaR | $0.008 |
POST /v1/risk/stress-test | Portfolio stress test across multiple scenarios | $0.008 |
POST /v1/risk/transaction-cost | Transaction cost model: commission + spread + Almgren market impact | $0.005 |
Indicators (6 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/indicators/technical | 13 technical indicators (SMA, EMA, RSI, MACD, etc.) + composite signals | $0.005 |
POST /v1/indicators/regime | Trend + volatility regime + composite risk classification | $0.005 |
POST /v1/indicators/crossover | Golden/death cross detection with signal history | $0.005 |
POST /v1/indicators/bollinger-bands | Bollinger Bands with %B, bandwidth, and squeeze detection | $0.002 |
POST /v1/indicators/fibonacci-retracement | Fibonacci retracement and extension levels | $0.002 |
POST /v1/indicators/atr | Average True Range with normalized ATR and volatility regime | $0.002 |
Statistics (12 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/stats/linear-regression | OLS linear regression with R-squared, t-stats, standard errors | $0.008 |
POST /v1/stats/polynomial-regression | Polynomial regression of degree n with goodness-of-fit metrics | $0.008 |
POST /v1/stats/cointegration | Engle-Granger cointegration test with hedge ratio and half-life | $0.008 |
POST /v1/stats/hurst-exponent | Hurst exponent via rescaled range (R/S) analysis | $0.008 |
POST /v1/stats/garch-forecast | GARCH(1,1) volatility forecast using maximum likelihood estimation | $0.015 |
POST /v1/stats/zscore | Rolling and static z-scores with extreme value detection | $0.002 |
POST /v1/stats/distribution-fit | Fit data to common distributions and rank by goodness of fit | $0.008 |
POST /v1/stats/correlation-matrix | Correlation and covariance matrices with eigenvalue decomposition | $0.015 |
POST /v1/stats/realized-volatility | Realized vol: close-to-close, Parkinson, Garman-Klass, Yang-Zhang | $0.005 |
POST /v1/stats/normal-distribution | Normal distribution: CDF, PDF, quantile, confidence intervals | $0.002 |
POST /v1/stats/sharpe-ratio | Standalone Sharpe ratio with Lo (2002) standard error and 95% CI | $0.002 |
POST /v1/stats/probabilistic-sharpe | Probabilistic Sharpe Ratio (Bailey & Lopez de Prado 2012) | $0.005 |
Portfolio (2 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/portfolio/optimize | Portfolio optimization: max Sharpe, min vol, or risk parity | $0.015 |
POST /v1/portfolio/risk-parity-weights | Equal risk contribution portfolio weights (Spinu 2013) | $0.008 |
Fixed Income (4 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/fixed-income/bond | Bond price, Macaulay/modified duration, convexity, DV01 | $0.008 |
POST /v1/fixed-income/amortization | Full amortization schedule with extra payment savings analysis | $0.005 |
POST /v1/fi/yield-curve-interpolate | Yield curve interpolation: linear, cubic spline, Nelson-Siegel | $0.015 |
POST /v1/fi/credit-spread | Credit spread and Z-spread from bond price vs risk-free curve | $0.008 |
Crypto / DeFi (7 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/crypto/impermanent-loss | Impermanent loss calculator for Uniswap v2/v3 AMM positions | $0.005 |
POST /v1/crypto/apy-apr-convert | Convert between APY and APR with configurable compounding | $0.002 |
POST /v1/crypto/liquidation-price | Liquidation price calculator for leveraged positions | $0.002 |
POST /v1/crypto/funding-rate | Funding rate analysis with annualization and regime detection | $0.005 |
POST /v1/crypto/dex-slippage | DEX slippage estimator for constant-product AMM (x*y=k) | $0.005 |
POST /v1/crypto/vesting-schedule | Token vesting schedule with cliff, linear/graded unlock, TGE | $0.005 |
POST /v1/crypto/rebalance-threshold | Portfolio rebalance analyzer: drift detection and trade sizing | $0.005 |
Live Data (2 endpoints) — paid tier, fresh market data
| Endpoint | Description | Price |
|---|---|---|
POST /v1/live/volatility | Live realized volatility (7d/30d/90d) + regime for a crypto asset | $0.01 |
POST /v1/live/funding-rates | Live perpetual funding rate + annualized carry for a crypto asset | $0.005 |
Paid from the first call (not part of the free tier); 20 free calls/IP/day. See QuantOracle Live.
Watch — position monitoring (6 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/watch/trial | Free 48-hour trial monitor (one per IP per 30 days) | Free |
POST /v1/watch/position | 24/7 monitoring of a perp position for 30 days | $5.00 |
POST /v1/watch/extend | Extend or upgrade a monitor by 30 days | $5.00 |
PATCH /v1/watch/{id} | Update position params (direction/entry/size/collateral/mmr/webhook/thresholds) | Free |
GET /v1/watch/{id} | Live status + alert history (token auth) | Free |
DELETE /v1/watch/{id} | Cancel a monitor | Free |
Priced per monitor, not per call. See QuantOracle Watch.
FX / Macro (7 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/fx/interest-rate-parity | Interest rate parity calculator with arbitrage detection | $0.005 |
POST /v1/fx/purchasing-power-parity | Purchasing power parity fair value estimation | $0.005 |
POST /v1/fx/forward-rate | Bootstrap forward rates from a spot yield curve | $0.005 |
POST /v1/fx/carry-trade | Currency carry trade P&L decomposition | $0.005 |
POST /v1/macro/inflation-adjusted | Nominal to real returns using Fisher equation | $0.002 |
POST /v1/macro/taylor-rule | Taylor Rule interest rate prescription | $0.002 |
POST /v1/macro/real-yield | Real yield and breakeven inflation from nominal yields | $0.002 |
Time Value of Money (5 endpoints)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/tvm/present-value | Present value of a future lump sum and/or annuity stream | $0.002 |
POST /v1/tvm/future-value | Future value of a present lump sum and/or annuity stream | $0.002 |
POST /v1/tvm/irr | Internal rate of return via Newton-Raphson | $0.005 |
POST /v1/tvm/npv | Net present value with profitability index and payback period | $0.002 |
POST /v1/tvm/cagr | Compound annual growth rate with forward projections | $0.002 |
Simulation (1 endpoint)
| Endpoint | Description | Price |
|---|---|---|
POST /v1/simulate/montecarlo | GBM Monte Carlo with contributions/withdrawals, up to 5000 paths | $0.015 |
Composite Endpoints (paid-only)
Higher-level endpoints that combine multiple calculations into a single call. Same math as the individual endpoints -- just packaged for common agent workflows. No free tier.
| Endpoint | Description | Replaces | Price |
|---|---|---|---|
POST /v1/backtest/strategy | Run SMA crossover, RSI mean reversion, momentum, or Bollinger breakout backtest | 10+ indicator + risk calls | $0.10 |
POST /v1/options/spread-scan | Scan and rank vertical spreads by risk/reward | 8-16 options/price calls | $0.05 |
POST /v1/portfolio/rebalance-plan | Generate trade list to hit target weights with cost estimate | portfolio/optimize + transaction-cost | $0.05 |
POST /v1/options/strategy-optimizer | Rank top options strategies given outlook + volatility view | options/strategy + payoff-diagram | $0.08 |
POST /v1/hedging/recommend | Rank cheapest effective hedges (protective put, collar, futures, partial) | options/price + Greeks | $0.04 |
POST /v1/risk/full-analysis | Complete risk tearsheet: Sharpe, Sortino, VaR, Kelly, drawdown, Hurst, CAGR | 7 individual calls | $0.04 |
POST /v1/portfolio/health | Portfolio health check: risk, correlation, rebalance, stress test | 6 individual calls | $0.04 |
POST /v1/trade/evaluate | Trade evaluation: sizing, risk/reward, Kelly, costs, regime, signals, verdict | 5 individual calls | $0.025 |
POST /v1/pairs/signal | Pairs trading signal: cointegration, Hurst, z-score, half-life, hedge ratio | 4 individual calls | $0.025 |
POST /v1/indicators/regime-classify | Trend, vol regime, RSI, direction, strategy suggestion | technical + regime + realized-vol | $0.015 |
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.
Strategy Optimizer (1,200+ calls)
examples/strategy_optimizer.py is a full walk-forward parameter optimizer that demonstrates heavy API usage:
| Phase | What it does | API calls |
|---|---|---|
| Parameter Sweep | Test 180 lookback/rebalance/RSI combinations across 8 assets | ~1,080 |
| Deep Analysis | 22 risk metrics + VaR + Kelly + Monte Carlo on top 3 configs | ~60-80 |
| Options Overlay | Price covered calls across 6 assets x 4 expiries x 5 strikes | ~100-150 |
| Pairs Analysis | Cointegration scan + Hurst exponent on 45 asset pairs | ~50-70 |
pip install requests
python examples/strategy_optimizer.py
A single run makes ~1,200-1,500 API calls. At paid rates that's ~$6-8 USDC. The same calculations done by an LLM in-context would cost $12-60 in tokens (Sonnet to Opus), take 4x longer, and get 15-30% of the complex math wrong.
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 calculators
- 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 calculators + 11 composites, pure Python math
worker/src/index.ts -- Cloudflare Worker: rate limiting + x402 payments (Base + Solana)
mcp-server/src/index.ts -- MCP server: 80 tools (incl. live data + Watch) over Streamable HTTP
cli/ -- quantoracle-cli: all endpoints in the terminal (npm)
tests/
test_integration.py -- 65 integration tests (all endpoints, live API)
accuracy_benchmarks.py -- 120 citation-backed accuracy tests
Stack: FastAPI + Pydantic | Cloudflare Workers + KV | MCP (Streamable HTTP) | x402 + CDP Facilitator | USDC on Base and Solana
License
MIT -- use QuantOracle however you want.