QuantOracle
63 herramientas deterministas de cómputo cuantitativo para agentes financieros autónomos. Valoración de opciones, derivados, riesgo, optimización de carteras, estadísticas, cripto/DeFi, macro/FX. 1,000 llamadas gratuitas al día, sin registro.
Documentación
QuantOracle
La API de cálculo cuantitativo para agentes financieros autónomos
63 calculadoras deterministas verificadas con citas + 10 flujos de trabajo compuestos. 1,000 llamadas gratuitas/día. Pago por llamada en Base o Solana.
Calculadoras | CLI | Servidor MCP | Pagos x402 | Nivel gratuito | Todos los endpoints | Integraciones
Pruébalo sin escribir código
12 calculadoras interactivas gratuitas respaldadas por la misma API están disponibles en quantoracle.dev — sin registro, sin clave API:
- Valoración de opciones Black-Scholes — precio call/put + griegas completas
- Opción americana (árbol binomial) — ejercicio anticipado + dividendos
- Calculadora de beneficios de opciones — diagramas de pago multi-pata
- Volatilidad implícita — solucionador IV Newton-Raphson
- Simulación Monte Carlo — escenarios de cartera y jubilación
- Criterio de Kelly — dimensionamiento Kelly completo / medio / cuarto
- Tamaño de posición — riesgo fraccional fijo
- Valor en riesgo (VaR) — VaR paramétrico + CVaR
- Ratio de Sharpe — con intervalo de confianza del 95%
- CAGR — tasa de crecimiento anual compuesta + proyecciones
- Precio de liquidación de cripto — largo/corto, cualquier apalancamiento
- Pérdida impermanente — Uniswap v2 + v3
¿Por qué QuantOracle?
Todo agente financiero necesita matemáticas. QuantOracle es esa matemática.
- 63 calculadoras puras en opciones, derivados, riesgo, cartera, estadística, cripto/DeFi, FX/macro y TVM
- 10 flujos de trabajo compuestos que agrupan 5-15 llamadas de calculadora (backtest de estrategias, planificación de rebalanceo, selección de estrategias de opciones, recomendaciones de cobertura, análisis de riesgo completo, señales de pares y más)
- Cero dependencias para las 73 calculadoras + compuestos — sin datos de mercado, cuentas o APIs de terceros; envía números, recibe números
- QuantOracle Live (nuevo) — un nivel de pago separado que trae los datos: volatilidad cripto fresca (
/v1/live/volatility) y tasas de financiación de perpetuos (/v1/live/funding-rates). Nosotros obtenemos los datos de mercado en vivo y ejecutamos las matemáticas, para que tu agente no tenga que hacerlo. 20 llamadas gratuitas/IP/día para evaluar, luego pago por llamada vía x402. - QuantOracle Watch (nuevo) — monitoreo de posición 24/7: registra una posición de perpetuo cripto una vez y recibe webhooks firmados con HMAC sobre distancia de liquidación ajustada por financiación, cambios de financiación y cambios de régimen de volatilidad — revisado cada 60 segundos. Prueba gratuita de 48h; $5 por posición por 30 días vía x402.
- Determinista — las calculadoras siempre producen los mismos resultados para las mismas entradas, para que los agentes puedan almacenar en caché, verificar y encadenar llamadas
- Verificado con citas — cada fórmula probada contra valores publicados en libros de texto (Hull, Wilmott, Bailey & Lopez de Prado)
- 120 benchmarks de precisión que pasan con soluciones analíticas
- Rápido — tiempo de cómputo de sub-milisegundo a 70ms por llamada
- Nivel gratuito — 1,000 llamadas/IP/día, sin clave API, sin registro, cero fricción
QuantOracle está diseñado para ser llamado repetidamente. Un agente que ejecuta un backtest podría llamar a 10+ endpoints por iteración. Ese es el modelo — ser la calculadora a la que los agentes recurren cada vez que necesitan matemáticas cuantitativas.
¿Por qué no simplemente dejar que el LLM haga las matemáticas?
| QuantOracle | Matemáticas en contexto del LLM | |
|---|---|---|
| Precisión | Exacta (fórmulas analíticas) | 70-85% en matemáticas complejas |
| Determinismo | Misma entrada = misma salida, siempre | Diferente en cada ejecución |
| Velocidad | <1ms por cálculo | 2-10s por generación |
| Costo | $0.002-0.015 por llamada | $0.01-0.10 por generación |
| Auditabilidad | Almacenable en caché, reproducible, comprobable | No reproducible |
| Valoración BS con 10 griegas | 1 llamada API, $0.005 | ~500 tokens, frecuentemente incorrecto en gamma/vanna |
📓 Libro de cocina LangChain
Construye un agente LangChain de 25 líneas que responde preguntas cuantitativas concretas — "Estoy largo $100k de NVDA a $185, ¿cómo debería cubrirme?" — con matemáticas deterministas y reproducibles:
integrations/langchain/cookbook/quantoracle_risk_analyst.ipynb

Se ejecuta en 30 segundos, ~$0.001 en tokens de OpenAI, gratuito para las calculadoras individuales de QuantOracle. El compuesto de recomendación de cobertura mostrado arriba cuesta $0.04 en USDC vía x402.
Añade QuantOracle a tu agente
Pega esto en el prompt del sistema de tu agente:
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)
URLs de descubrimiento (para frameworks de agentes y rastreadores)
| Formato | URL |
|---|---|
| Especificación OpenAPI | https://api.quantoracle.dev/openapi.json |
| Listado de herramientas | https://api.quantoracle.dev/tools |
| Endpoint MCP | npx quantoracle-mcp |
| Plugin de IA | https://api.quantoracle.dev/.well-known/ai-plugin.json |
| Tarjeta de servidor | https://mcp.quantoracle.dev/.well-known/mcp/server-card.json |
| Documentación Swagger | https://api.quantoracle.dev/docs |
Inicio rápido
# 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
Las 63 calculadoras + 10 compuestos en tu terminal. Cero dependencias.
npm install -g quantoracle-cli
O ejecuta sin instalar:
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
Nivel gratuito
1,000 llamadas gratuitas por IP por día. Sin registro. Sin clave API. Solo llama a la API.
| Gratuito | De pago (x402) | |
|---|---|---|
| Llamadas | 1,000/día | Ilimitadas |
| Autenticación | Ninguna | Cabecera de micropago x402 |
| Calculadoras | Las 63 | Las 63 |
| Flujos de trabajo compuestos | Ninguno (solo de pago) | Los 10 |
| Nivel de datos en vivo | 20 llamadas/día | Pago por llamada |
| Monitoreo Watch | Prueba gratuita de 48h (1 por IP / 30d) | $5 por posición / 30 días |
| Cabeceras de límite | Sí | Sí |
Cada respuesta incluye cabeceras de límite de tasa para que los agentes puedan autogestionarse:
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 847
X-RateLimit-Reset: 2025-01-15T00:00:00Z
Consulta el uso en cualquier momento:
curl https://api.quantoracle.dev/usage
Después de 1,000 llamadas, la API devuelve 402 Payment Required con una cabecera de pago x402. Cualquier agente compatible con x402 paga automáticamente y continúa:
HTTP/1.1 402 Payment Required
PAYMENT-REQUIRED: <base64-encoded payment instructions>
| Nivel | Precio | Endpoints |
|---|---|---|
| Simple | $0.002 | Z-score, APY/APR, Fibonacci, Bollinger, ATR, regla de Taylor, inflación, rendimiento real, PV, FV, NPV, CAGR, distribución normal, ratio de Sharpe, precio de liquidación, paridad put-call |
| Medio | $0.005 | Black-Scholes, volatilidad implícita, Kelly, dimensionamiento de posición, drawdown, régimen, cruce, amortización de bonos, carry trade, IRP, PPP, tasa de financiación, slippage, vesting, rebalanceo, IRR, volatilidad realizada, PSR, costo de transacción |
| Complejo | $0.008 | Riesgo de cartera, árbol binomial, opciones barrera/asiáticas/lookback, diferencial de crédito, VaR, prueba de estrés, regresión, cointegración, Hurst, ajuste de distribución, paridad de riesgo |
| Pesado | $0.015 | Monte Carlo, GARCH, optimización de cartera, análisis de cadena de opciones, superficie de volatilidad, curva de rendimiento, matriz de correlación |
| Compuesto | $0.015-0.10 | Estrategia de backtest, escaneo de spreads, plan de rebalanceo, optimizador de estrategias de opciones, recomendación de cobertura, análisis de riesgo completo, evaluación de operaciones, salud de cartera, señal de pares, clasificación de régimen (solo de pago, sin nivel gratuito) |
Endpoint de lote
Ejecuta hasta 100 cálculos en una sola solicitud HTTP. Un solo viaje de ida y vuelta en lugar de 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}}
]
}'
Devuelve todos los resultados en una sola respuesta con el precio total:
{
"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
}
| Gratuito | De pago | |
|---|---|---|
| Llamadas de lote | 1 prueba (por siempre) | Ilimitadas |
| Máximo por lote | 100 | 100 |
| Precio | Gratis | Suma de los precios de endpoints individuales |
El precio del lote es la suma de los precios de los endpoints individuales — sin recargo. Pagas por los cálculos, la velocidad es gratuita.
QuantOracle Live — datos de mercado frescos + cómputo
Cada endpoint anterior es matemática pura sobre entradas que tú proporcionas — las 73 calculadoras tienen cero dependencias de datos, lo que las hace deterministas y almacenables en caché. QuantOracle Live es el único nivel que trae los datos: pasas un ticker, la API obtiene datos de mercado frescos y ejecuta las matemáticas, para que tu agente nunca tenga que obtener o mantener un feed de datos.
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/live/volatility | Volatilidad realizada (7d/30d/90d) + régimen para un activo cripto, a partir de velas diarias frescas | $0.01 |
POST /v1/live/funding-rates | Tasa de financiación de perpetuos actual + carry anualizado para un activo cripto | $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", ...}
Precios: el nivel Live es de pago desde la primera llamada — no es parte del nivel gratuito de 1,000/día de calculadoras (el valor son los datos frescos + el pipeline, que no puedes replicar con una biblioteca local). Recibes 20 llamadas gratuitas por IP por día para evaluar, luego se liquida por llamada vía x402 (USDC en Base o Solana). Pagas por la frescura, no por la aritmética.
Los resultados se almacenan en caché en el servidor (volatilidad ~5 min, financiación ~1 min); si un feed ascendente no está disponible brevemente, la API sirve el último valor bueno marcado stale: true, con as_of_age_seconds indicando qué tan fresco es el resultado.
QuantOracle Watch — monitoreo de posición 24/7
La mayoría de los agentes de monitoreo reconstruyen el mismo bucle: consultar crypto/liquidation-price + risk/var-parametric en un temporizador, todo el día. Watch reemplaza el bucle — registra una posición de perpetuo cripto una vez y un vigilante aislado la reevalúa cada ~60 segundos: distancia de liquidación ajustada por financiación (bandas de advertencia/críticas con histéresis), cambios de signo en la tasa de financiación, cambios de régimen de volatilidad por hora y advertencias de vencimiento. Las alertas se envían como webhooks firmados con HMAC (X-QO-Signature, clave = tu token de monitor) y se registran en el servidor, por lo que la prueba no necesita infraestructura — solo consulta.
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/watch/trial | Monitor gratuito de 48 horas — uno por IP por 30 días | Gratis |
POST /v1/watch/position | Registra una posición para 30 días de monitoreo | $5.00 |
POST /v1/watch/extend | +30 días (también actualiza una prueba; cuerpo: {monitor_id, token}) | $5.00 |
PATCH /v1/watch/{id} | Actualiza los parámetros de la posición después de añadir margen / redimensionar / moverla | Gratis |
GET /v1/watch/{id} | Estado en vivo + historial de alertas (autenticación por token) | Gratis |
DELETE /v1/watch/{id} | Cancelar | Gratis |
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_...", ...}
Sin claves de exchange, sin custodia, sin ejecución — Watch lee datos de mercado públicos y envía webhooks, por lo que el peor modo de fallo es una alerta perdida (el latido del vigilante se publica en /health como watcher_heartbeat_age_s). Los destinos de webhook están protegidos contra SSRF y las entregas se reintentan. La economía: un bucle DIY consultando las mismas matemáticas una vez por minuto más allá del nivel gratuito cuesta ~$7.20/día en tarifas por llamada vs $5 por 30 días. Guía completa: quantoracle.dev/writing/crypto-liquidation-alerts-for-agents.
Pagos x402
QuantOracle utiliza el protocolo x402 para micropagos de pago por llamada. Cuando un agente agota su nivel gratuito (o llama a un compuesto solo de pago), la API devuelve una respuesta estándar 402 con instrucciones de pago que anuncian tanto Base como Solana. Los agentes compatibles con x402 (Coinbase AgentKit, AgentCash, OpenClaw, etc.) manejan el resto automáticamente:
- El agente llama al endpoint, obtiene
402con la cabeceraPAYMENT-REQUIREDque lista las redes aceptadas - El agente firma una autorización de transferencia USDC sin gas en Base (EIP-3009) o Solana
- El agente reenvía la solicitud con la cabecera
PAYMENT-SIGNATURE - El servidor verifica vía facilitador CDP, sirve la respuesta, liquida en cadena
Sin claves API. Sin suscripciones. Sin cuentas. Solo matemáticas y micropagos.
Redes compatibles
| Red | Activo | Gas | Mejor para |
|---|---|---|---|
Base mainnet (eip155:8453) | USDC (0x8335...) | ~$0.005/tx | Agentes EVM, herramientas de Coinbase, LangChain, ecosistema Base |
Solana mainnet (solana:5eykt4...) | USDC (EPjFWdd5...) | ~$0.0002/tx (pagador de tarifas CDP) | Solana Agent Kit, Eliza, bots de alta frecuencia |
- Liquidación: A través del facilitador de Coinbase Developer Platform (
api.cdp.coinbase.com/platform/v2/x402) - Billetera Base:
0xC94f5F33ae446a50Ce31157db81253BfddFE2af6 - Billetera Solana:
9biztrXscReJ3Wi8EfkD2gL3WXzYUmzTEohD26Bxp39u - Descubrimiento:
https://api.quantoracle.dev/.well-known/x402(devuelve ambas cadenas para cada endpoint)
Pruébalo con 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]}'
Servidor MCP
QuantOracle está disponible como servidor MCP nativo con 80 herramientas (63 calculadoras + 11 compuestas + 2 endpoints de datos de mercado en vivo + 3 herramientas de monitoreo de QuantOracle Watch + lote). Funciona con Claude Desktop, Cursor, Windsurf, Smithery y cualquier cliente compatible con MCP.
Instalación mediante npm
npx quantoracle-mcp
Claude Desktop / Claude Code
Añádelo como conector en Configuración, o añádelo a claude_desktop_config.json:
{
"mcpServers": {
"quantoracle": {
"url": "https://mcp.quantoracle.dev/mcp"
}
}
}
O ejecútalo localmente mediante npx:
{
"mcpServers": {
"quantoracle": {
"command": "npx",
"args": ["-y", "quantoracle-mcp"]
}
}
}
MCP remoto (Streamable HTTP)
Conéctate directamente al servidor alojado — no se requiere instalación:
https://mcp.quantoracle.dev/mcp
Smithery
npx @smithery/cli mcp add https://server.smithery.ai/QuantOracle/quantoracle
OpenClaw / ClawHub
clawhub install quantoracle
Integraciones
QuantOracle está disponible en múltiples ecosistemas de agentes:
| Plataforma | Cómo conectarse |
|---|---|
| Claude Desktop / Claude Code | URL del conector: https://mcp.quantoracle.dev/mcp |
| Cursor / Windsurf | Configuración MCP: npx quantoracle-mcp |
| Smithery | npx @smithery/cli mcp add QuantOracle/quantoracle |
| OpenClaw / ClawHub | clawhub install quantoracle |
| CLI | npm install -g quantoracle-cli o npx quantoracle-cli |
| Glama | glama.ai/mcp/servers/QuantOracledev/quantoracle |
| npm (MCP) | npx quantoracle-mcp |
| Ecosistema x402 | x402.org/ecosystem |
| ChatGPT GPT | QuantOracle GPT |
| LangChain | pip install langchain-quantoracle |
| AgentCash | npx agentcash fetch https://api.quantoracle.dev/v1/... |
| x402scan | Página del servidor — Base + Solana |
| API REST | https://api.quantoracle.dev/v1/... |
| Especificación OpenAPI | https://api.quantoracle.dev/openapi.json |
| Swagger UI | https://api.quantoracle.dev/docs |
Descubrimiento de herramientas
# 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
Referencia completa de endpoints
Opciones (4 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/options/price | Precio Black-Scholes con 10 griegas (delta hasta color) | $0.005 |
POST /v1/options/implied-vol | Solucionador de volatilidad implícita Newton-Raphson | $0.005 |
POST /v1/options/strategy | Estrategia de opciones multi-pierna: P&L, puntos de equilibrio, ganancia/pérdida máxima | $0.008 |
POST /v1/options/payoff-diagram | Generación de datos de diagrama de pago de opciones multi-pierna | $0.005 |
Derivados (7 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/derivatives/binomial-tree | Precio de árbol binomial CRR para opciones americanas y europeas | $0.008 |
POST /v1/derivatives/barrier-option | Precio de opciones barrera usando fórmulas analíticas | $0.008 |
POST /v1/derivatives/asian-option | Precio de opciones asiáticas: forma cerrada geométrica o aproximación aritmética | $0.008 |
POST /v1/derivatives/lookback-option | Precio de opciones lookback (strike flotante/fijo, Goldman-Sosin-Gatto) | $0.008 |
POST /v1/derivatives/option-chain-analysis | Analítica de cadena de opciones: sesgo, max pain, ratios put-call | $0.015 |
POST /v1/derivatives/put-call-parity | Verificación de paridad put-call y detección de arbitraje | $0.002 |
POST /v1/derivatives/volatility-surface | Construir superficie de volatilidad implícita a partir de datos de mercado | $0.015 |
Riesgo (8 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/risk/portfolio | 22 métricas de riesgo: Sharpe, Sortino, Calmar, Omega, VaR, CVaR, drawdown | $0.008 |
POST /v1/risk/kelly | Criterio de Kelly: discreto (ganancia/pérdida) o continuo (serie de retornos) | $0.005 |
POST /v1/risk/position-size | Dimensionamiento de posición fraccional fija con objetivos de riesgo/recompensa | $0.005 |
POST /v1/risk/drawdown | Descomposición de drawdown con curva bajo el agua | $0.005 |
POST /v1/risk/correlation | Matrices de correlación y covarianza N x N a partir de series de retornos | $0.008 |
POST /v1/risk/var-parametric | Valor en riesgo paramétrico y VaR condicional | $0.008 |
POST /v1/risk/stress-test | Prueba de estrés de cartera en múltiples escenarios | $0.008 |
POST /v1/risk/transaction-cost | Modelo de costos de transacción: comisión + spread + impacto de mercado Almgren | $0.005 |
Indicadores (6 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/indicators/technical | 13 indicadores técnicos (SMA, EMA, RSI, MACD, etc.) + señales compuestas | $0.005 |
POST /v1/indicators/regime | Tendencia + régimen de volatilidad + clasificación de riesgo compuesta | $0.005 |
POST /v1/indicators/crossover | Detección de cruce dorado/de la muerte con historial de señales | $0.005 |
POST /v1/indicators/bollinger-bands | Bandas de Bollinger con %B, ancho de banda y detección de compresión | $0.002 |
POST /v1/indicators/fibonacci-retracement | Niveles de retroceso y extensión de Fibonacci | $0.002 |
POST /v1/indicators/atr | Rango Verdadero Promedio con ATR normalizado y régimen de volatilidad | $0.002 |
Estadísticas (12 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/stats/linear-regression | Regresión lineal OLS con R-cuadrado, estadísticos t, errores estándar | $0.008 |
POST /v1/stats/polynomial-regression | Regresión polinomial de grado n con métricas de bondad de ajuste | $0.008 |
POST /v1/stats/cointegration | Prueba de cointegración Engle-Granger con ratio de cobertura y vida media | $0.008 |
POST /v1/stats/hurst-exponent | Exponente de Hurst mediante análisis de rango reescalado (R/S) | $0.008 |
POST /v1/stats/garch-forecast | Pronóstico de volatilidad GARCH(1,1) usando estimación de máxima verosimilitud | $0.015 |
POST /v1/stats/zscore | Puntuaciones z móviles y estáticas con detección de valores extremos | $0.002 |
POST /v1/stats/distribution-fit | Ajustar datos a distribuciones comunes y clasificar por bondad de ajuste | $0.008 |
POST /v1/stats/correlation-matrix | Matrices de correlación y covarianza con descomposición de valores propios | $0.015 |
POST /v1/stats/realized-volatility | Volatilidad realizada: cierre a cierre, Parkinson, Garman-Klass, Yang-Zhang | $0.005 |
POST /v1/stats/normal-distribution | Distribución normal: CDF, PDF, cuantil, intervalos de confianza | $0.002 |
POST /v1/stats/sharpe-ratio | Ratio de Sharpe independiente con error estándar de Lo (2002) e IC del 95% | $0.002 |
POST /v1/stats/probabilistic-sharpe | Ratio de Sharpe probabilístico (Bailey y López de Prado 2012) | $0.005 |
Cartera (2 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/portfolio/optimize | Optimización de cartera: máximo Sharpe, mínima volatilidad o paridad de riesgo | $0.015 |
POST /v1/portfolio/risk-parity-weights | Pesos de cartera de contribución de riesgo igual (Spinu 2013) | $0.008 |
Renta Fija (4 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/fixed-income/bond | Precio de bono, duración Macaulay/modificada, convexidad, DV01 | $0.008 |
POST /v1/fixed-income/amortization | Calendario de amortización completo con análisis de ahorro por pagos extra | $0.005 |
POST /v1/fi/yield-curve-interpolate | Interpolación de curva de rendimiento: lineal, spline cúbico, Nelson-Siegel | $0.015 |
POST /v1/fi/credit-spread | Spread de crédito y Z-spread a partir del precio del bono frente a la curva libre de riesgo | $0.008 |
Cripto / DeFi (7 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/crypto/impermanent-loss | Calculadora de pérdida impermanente para posiciones AMM de Uniswap v2/v3 | $0.005 |
POST /v1/crypto/apy-apr-convert | Convertir entre APY y APR con capitalización configurable | $0.002 |
POST /v1/crypto/liquidation-price | Calculadora de precio de liquidación para posiciones apalancadas | $0.002 |
POST /v1/crypto/funding-rate | Análisis de tasa de financiación con anualización y detección de régimen | $0.005 |
POST /v1/crypto/dex-slippage | Estimador de deslizamiento DEX para AMM de producto constante (x*y=k) | $0.005 |
POST /v1/crypto/vesting-schedule | Calendario de vesting de tokens con cliff, desbloqueo lineal/escalonado, TGE | $0.005 |
POST /v1/crypto/rebalance-threshold | Analizador de rebalanceo de cartera: detección de deriva y dimensionamiento de operaciones | $0.005 |
Datos en Vivo (2 endpoints) — nivel de pago, datos de mercado frescos
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/live/volatility | Volatilidad realizada en vivo (7d/30d/90d) + régimen para un activo cripto | $0.01 |
POST /v1/live/funding-rates | Tasa de financiación perpetua en vivo + carry anualizado para un activo cripto | $0.005 |
Se paga desde la primera llamada (no forma parte del nivel gratuito); 20 llamadas gratuitas/IP/día. Ver QuantOracle Live.
Watch — monitoreo de posiciones (6 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/watch/trial | Monitor de prueba gratuito de 48 horas (uno por IP cada 30 días) | Gratis |
POST /v1/watch/position | Monitoreo 24/7 de una posición perpetua durante 30 días | $5.00 |
POST /v1/watch/extend | Extender o mejorar un monitor por 30 días | $5.00 |
PATCH /v1/watch/{id} | Actualizar parámetros de posición (dirección/entrada/tamaño/colateral/mmr/webhook/umbrales) | Gratis |
GET /v1/watch/{id} | Estado en vivo + historial de alertas (autenticación por token) | Gratis |
DELETE /v1/watch/{id} | Cancelar un monitor | Gratis |
Precio por monitor, no por llamada. Ver QuantOracle Watch.
FX / Macro (7 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/fx/interest-rate-parity | Calculadora de paridad de tasas de interés con detección de arbitraje | $0.005 |
POST /v1/fx/purchasing-power-parity | Estimación de valor justo de paridad de poder adquisitivo | $0.005 |
POST /v1/fx/forward-rate | Bootstrapping de tasas forward a partir de una curva de rendimiento spot | $0.005 |
POST /v1/fx/carry-trade | Descomposición de P&L de carry trade de divisas | $0.005 |
POST /v1/macro/inflation-adjusted | Retornos nominales a reales usando la ecuación de Fisher | $0.002 |
POST /v1/macro/taylor-rule | Prescripción de tasa de interés de la Regla de Taylor | $0.002 |
POST /v1/macro/real-yield | Rendimiento real e inflación de equilibrio a partir de rendimientos nominales | $0.002 |
Valor del Dinero en el Tiempo (5 endpoints)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/tvm/present-value | Valor presente de una suma global futura y/o flujo de anualidad | $0.002 |
POST /v1/tvm/future-value | Valor futuro de una suma global presente y/o flujo de anualidad | $0.002 |
POST /v1/tvm/irr | Tasa interna de retorno mediante Newton-Raphson | $0.005 |
POST /v1/tvm/npv | Valor presente neto con índice de rentabilidad y período de recuperación | $0.002 |
POST /v1/tvm/cagr | Tasa de crecimiento anual compuesta con proyecciones futuras | $0.002 |
Simulación (1 endpoint)
| Endpoint | Descripción | Precio |
|---|---|---|
POST /v1/simulate/montecarlo | Monte Carlo GBM con contribuciones/retiros, hasta 5000 trayectorias | $0.015 |
Endpoints Compuestos (solo de pago)
Endpoints de nivel superior que combinan múltiples cálculos en una sola llamada. Misma matemática que los endpoints individuales — solo empaquetados para flujos de trabajo comunes de agentes. Sin nivel gratuito.
| Endpoint | Descripción | Reemplaza | Precio |
|---|---|---|---|
POST /v1/backtest/strategy | Ejecutar backtest de cruce SMA, reversión a la media RSI, momentum o ruptura de Bollinger | 10+ llamadas de indicadores + riesgo | $0.10 |
POST /v1/options/spread-scan | Escanear y clasificar spreads verticales por riesgo/recompensa | 8-16 llamadas de opciones/precio | $0.05 |
POST /v1/portfolio/rebalance-plan | Generar lista de operaciones para alcanzar pesos objetivo con estimación de costos | cartera/optimizar + costo de transacción | $0.05 |
POST /v1/options/strategy-optimizer | Clasificar las mejores estrategias de opciones según perspectiva + visión de volatilidad | opciones/estrategia + diagrama de pago | $0.08 |
POST /v1/hedging/recommend | Clasificar las coberturas efectivas más baratas (put protector, collar, futuros, parcial) | opciones/precio + griegas | $0.04 |
POST /v1/risk/full-analysis | Hoja de riesgo completa: Sharpe, Sortino, VaR, Kelly, drawdown, Hurst, CAGR | 7 llamadas individuales | $0.04 |
POST /v1/portfolio/health | Chequeo de salud de cartera: riesgo, correlación, rebalanceo, prueba de estrés | 6 llamadas individuales | $0.04 |
POST /v1/trade/evaluate | Evaluación de operación: dimensionamiento, riesgo/recompensa, Kelly, costos, régimen, señales, veredicto | 5 llamadas individuales | $0.025 |
POST /v1/pairs/signal | Señal de trading de pares: cointegración, Hurst, z-score, vida media, ratio de cobertura | 4 llamadas individuales | $0.025 |
POST /v1/indicators/regime-classify | Tendencia, régimen de volatilidad, RSI, dirección, sugerencia de estrategia | técnico + régimen + volatilidad realizada | $0.015 |
Ejemplo: Flujo de trabajo de backtest de agente
Un backtest típico de agente encadena múltiples llamadas a QuantOracle por iteración:
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
Cada llamada es una calculadora pura — sin estado, sin efectos secundarios, sin claves API.
Optimizador de Estrategias (más de 1,200 llamadas)
examples/strategy_optimizer.py es un optimizador de parámetros walk-forward completo que demuestra un uso intensivo de la API:
| Fase | Qué hace | Llamadas a la API |
|---|---|---|
| Barrido de Parámetros | Prueba 180 combinaciones de lookback/rebalance/RSI en 8 activos | ~1,080 |
| Análisis Profundo | 22 métricas de riesgo + VaR + Kelly + Monte Carlo en las 3 mejores configuraciones | ~60-80 |
| Superposición de Opciones | Cotiza covered calls en 6 activos x 4 vencimientos x 5 strikes | ~100-150 |
| Análisis de Pares | Escaneo de cointegración + exponente de Hurst en 45 pares de activos | ~50-70 |
pip install requests
python examples/strategy_optimizer.py
Una sola ejecución realiza aproximadamente 1,200-1,500 llamadas a la API. A tarifas de pago, eso equivale a ~$6-8 USDC. Los mismos cálculos realizados por un LLM en contexto costarían $12-60 en tokens (de Sonnet a Opus), tomarían 4 veces más tiempo y fallarían en el 15-30% de los cálculos matemáticos complejos.
Autoalojamiento
# 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
Precisión
Cada endpoint se prueba contra soluciones analíticas publicadas:
- 120 benchmarks respaldados por citas (Hull, Wilmott, Bailey & Lopez de Prado, Goldman-Sosin-Gatto, Taylor, Fisher, Markowitz)
- Más de 65 pruebas de integración que cubren las 63 calculadoras
- Matemáticas puras en Python -- sin numpy/scipy, cero dependencias nativas
- Determinista: las mismas entradas siempre producen las mismas salidas
Ejecute el conjunto de verificación usted mismo:
python tests/accuracy_benchmarks.py https://api.quantoracle.dev
Arquitectura
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 en Base y Solana
Licencia
MIT -- use QuantOracle como desee.