trackmcp
Back to directory
QuantOracledev

quantoracle

View on GitHub

63 deterministic quant computation tools for autonomous financial agents. Options, derivatives, risk, portfolio, statistics, crypto/DeFi, macro/FX, TVM. 1,000 free calls/day — no signup.

11 stars TypeScriptOthers Updated Sep 3, 2026
backtestingblack-scholescryptodefiderivativesfastapifinancemcpmonte-carlooptions-pricingportfolio-optimizationquantitative-financerisk-managementx402ai-agentmcp-serveragentkitkelly-criterionlangchainusdc

Documentation

QuantOracle

The quantitative computation API for autonomous financial agents

63 deterministic, citation-verified calculators + 10 composite workflows. 1,000 free calls/day. Pay-per-call on Base or Solana.

  
  
  
  
  
  

Try it without writing code

12 free interactive calculators backed by the same API are live at **quantoracle.dev** — no signup, no API key:


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?

QuantOracleLLM in-context math
AccuracyExact (analytical formulas)70-85% on complex math
DeterminismSame input = same output, alwaysDifferent every run
Speed
code
| 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}}

]

}'

code
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

}

code
| | 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", ...}

code
**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_...", ...}

code
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](https://api.quantoracle.dev/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](https://quantoracle.dev/writing/crypto-liquidation-alerts-for-agents).

## x402 Payments

QuantOracle uses the [x402 protocol](https://x402.org) 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:

1. Agent calls endpoint, gets `402` with `PAYMENT-REQUIRED` header listing accepted networks
2. Agent signs a gasless USDC transfer authorization on Base (EIP-3009) or Solana
3. Agent resends request with `PAYMENT-SIGNATURE` header
4. 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]}'

code
---

## 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

code
### 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"

}

}

}

code
Or run locally via npx:

{

"mcpServers": {

"quantoracle": {

"command": "npx",

"args": ["-y", "quantoracle-mcp"]

}

}

}

code
### Remote MCP (Streamable HTTP)

Connect directly to the hosted server — no install required:

https://mcp.quantoracle.dev/mcp

code
### Smithery

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

code
### OpenClaw / ClawHub

clawhub install quantoracle

code
---

## 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](https://glama.ai/mcp/servers/QuantOracledev/quantoracle) |
| **npm (MCP)** | `npx quantoracle-mcp` |
| **x402 ecosystem** | [x402.org/ecosystem](https://x402.org/ecosystem) |
| **ChatGPT GPT** | [QuantOracle GPT](https://chatgpt.com/g/g-69d9c28bddb481918e674e2f9d9f3e97-quantoracle) |
| **LangChain** | `pip install langchain-quantoracle` |
| **AgentCash** | `npx agentcash fetch https://api.quantoracle.dev/v1/...` |
| **x402scan** | [Server page](https://www.x402scan.com/server/2c32a45a-f94b-4def-904c-8dbbac8dc042) — 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

code
---

## 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](#quantoracle-live--fresh-market-data--compute).*

### 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](#quantoracle-watch--247-position-monitoring).*

### 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

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

### Strategy Optimizer (1,200+ calls)

[`examples/strategy_optimizer.py`](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

code
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

code
---

## 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

code
---

## 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

code
**Stack**: FastAPI + Pydantic | Cloudflare Workers + KV | MCP (Streamable HTTP) | x402 + CDP Facilitator | USDC on Base and Solana

---

## License

[MIT](LICENSE) -- use QuantOracle however you want.

Frequently asked questions

What is quantoracle?

quantoracle is 63 deterministic quant computation tools for autonomous financial agents. Options, derivatives, risk, portfolio, statistics, crypto/DeFi, macro/FX, TVM. 1,000 free calls/day — no signup.

How do I install quantoracle?

Open the GitHub repository and follow its README. Most MCP servers are added to your client's MCP config, then called by your agent.

Is quantoracle open source?

Yes — it is hosted on GitHub at https://github.com/QuantOracledev/quantoracle and has 11 stars.

Related MCP tools

Run your own MCP server? See who uses it and what to fix.

Measure it with TrackMCP