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
Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y [email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add quantoracledev-quantoracle -- npx -y quantoracle-mcp@2.4.2รันในเทอร์มินัล
{ "mcpServers": { "quantoracledev-quantoracle": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
12 free interactive calculators backed by the same API are live at quantoracle.dev — no signup, no API key:
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.
Every financial agent needs math. QuantOracle is that math.
/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 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.
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:

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.
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)
# 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
}
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
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;
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
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, 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>
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
}
Batch pricing is the sum of the individual endpoint prices — no markup. You pay for the computations, the speed is free.
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.
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.
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.
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.
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:
402 with PAYMENT-REQUIRED header listing accepted networksPAYMENT-SIGNATURE headerNo API keys. No subscriptions. No accounts. Just math and micropayments.
api.cdp.coinbase.com/platform/v2/x402)0xC94f5F33ae446a50Ce31157db81253BfddFE2af69biztrXscReJ3Wi8EfkD2gL3WXzYUmzTEohD26Bxp39uhttps://api.quantoracle.dev/.well-known/x402 (returns both chains for every endpoint)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]}'
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.
npx quantoracle-mcp
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"]
}
}
}
Connect directly to the hosted server — no install required:
https://mcp.quantoracle.dev/mcp
npx @smithery/cli mcp add https://server.smithery.ai/QuantOracle/quantoracle
clawhub install quantoracle
QuantOracle is available across multiple agent ecosystems:
# 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
Paid from the first call (not part of the free tier); 20 free calls/IP/day. See QuantOracle Live.
Priced per monitor, not per call. See QuantOracle Watch.
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.
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.
examples/strategy_optimizer.py is a full walk-forward parameter optimizer that demonstrates heavy API usage:
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.
# 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
Every endpoint is tested against published analytical solutions:
Run the verification suite yourself:
python tests/accuracy_benchmarks.py https://api.quantoracle.dev
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
MIT -- use QuantOracle however you want.
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.
{ "mcpServers": { "quantoracledev-quantoracle": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Quantoracle ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-10-28 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.