QuantOracle

63 ferramentas determinísticas de computação quant para agentes financeiros autônomos. Precificação de opções, derivativos, risco, otimização de portfólio, estatísticas, cripto/DeFi, macro/FX. 1.000 chamadas gratuitas/dia, sem cadastro.

GitHub

Experimente este MCPPatrocinado

Documentação

QuantOracle

A API de computação quantitativa para agentes financeiros autônomos

63 calculadoras determinísticas verificadas por citações + 10 fluxos de trabalho compostos. 1.000 chamadas gratuitas/dia. Pague por chamada na Base ou Solana.

Experimente sem escrever código

12 calculadoras interativas gratuitas com suporte da mesma API estão disponíveis em quantoracle.dev — sem cadastro, sem chave de API:

Precificação de Opções Black-Scholes — preço de compra/venda + Gregas completas
Opção Americana (Árvore Binomial) — exercício antecipado + dividendos
Calculadora de Lucro de Opções — diagramas de payoff multi-perna
Volatilidade Implícita — solucionador IV Newton-Raphson
Simulação de Monte Carlo — cenários de portfólio + aposentadoria
Critério de Kelly — dimensionamento Kelly completo / meio / quarto
Tamanho da Posição — risco fracionário fixo
Valor em Risco (VaR) — VaR paramétrico + CVaR
Índice de Sharpe — com intervalo de confiança de 95%
CAGR — taxa de crescimento anual composta + projeções
Preço de Liquidação de Cripto — comprado/vendido, qualquer alavancagem
Perda Impermanente — Uniswap v2 + v3

Por que QuantOracle?

Todo agente financeiro precisa de matemática. QuantOracle é essa matemática.

63 calculadoras puras em opções, derivativos, risco, portfólio, estatística, cripto/DeFi, FX/macroeconomia e TVM
10 fluxos de trabalho compostos que agrupam 5-15 chamadas de calculadora (backtest de estratégias, planejamento de rebalanceamento, seleção de estratégia de opções, recomendações de hedge, análise de risco completa, sinais de pares e mais)
Zero dependências para as 73 calculadoras + compostos — sem dados de mercado, contas ou APIs de terceiros; envie números, receba números
QuantOracle Live (novo) — um plano pago separado que traz os dados: volatilidade cripto atualizada (/v1/live/volatility) e taxas de funding perpétuo (/v1/live/funding-rates). Nós buscamos os dados de mercado ao vivo e executamos a matemática, para que seu agente não precise. 20 chamadas gratuitas/IP/dia para avaliar, depois pague por chamada via x402.
QuantOracle Watch (novo) — monitoramento de posição 24/7: registre uma posição perpétua de cripto uma vez e receba webhooks assinados com HMAC sobre distância de liquidação ajustada por funding, inversões de funding e mudanças de regime de volatilidade — verificados a cada 60 segundos. Teste gratuito de 48h; $5 por posição a cada 30 dias via x402.
Determinístico — as calculadoras sempre produzem as mesmas saídas para as mesmas entradas, para que os agentes possam armazenar em cache, verificar e encadear chamadas
Verificado por citações — cada fórmula testada contra valores publicados em livros-texto (Hull, Wilmott, Bailey & Lopez de Prado)
120 benchmarks de precisão passando com soluções analíticas
Rápido — tempo de computação de submilissegundo a 70ms por chamada
Plano gratuito — 1.000 chamadas/IP/dia, sem chave de API, sem cadastro, zero atrito

QuantOracle é projetado para ser chamado repetidamente. Um agente executando um backtest pode chamar 10+ endpoints por iteração. Esse é o modelo — seja a calculadora que os agentes procuram sempre que precisam de matemática quantitativa.

Por que não apenas deixar o LLM fazer a matemática?

	QuantOracle	Matemática em contexto do LLM
Precisão	Exata (fórmulas analíticas)	70-85% em matemática complexa
Determinismo	Mesma entrada = mesma saída, sempre	Diferente a cada execução
Velocidade	<1ms por cálculo	2-10s por geração
Custo	$0,002-0,015 por chamada	$0,01-0,10 por geração
Auditabilidade	Armazenável em cache, reproduzível, testável	Não reproduzível
Precificação BS com 10 Gregas	1 chamada de API, $0,005	~500 tokens, frequentemente errado em gamma/vanna

📓 Livro de receitas LangChain

Construa um agente LangChain de 25 linhas que responde perguntas quantitativas concretas — "Estou comprado em $100k de NVDA a $185, como devo fazer hedge?" — com matemática determinística e reproduzível:

integrations/langchain/cookbook/quantoracle_risk_analyst.ipynb

QuantOracle × LangChain hedging composite

Executa em 30 segundos, ~$0,001 em tokens OpenAI, gratuito para as calculadoras individuais do QuantOracle. O composto de recomendação de hedge mostrado acima custa $0,04 em USDC via x402.

Adicione QuantOracle ao Seu Agente

Cole isto no prompt de sistema do seu 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 descoberta (para frameworks de agentes e rastreadores)

Formato	URL
Especificação OpenAPI	`https://api.quantoracle.dev/openapi.json`
Listagem de ferramentas	`https://api.quantoracle.dev/tools`
Endpoint MCP	`npx quantoracle-mcp`
Plugin de IA	`https://api.quantoracle.dev/.well-known/ai-plugin.json`
Cartão do servidor	`https://mcp.quantoracle.dev/.well-known/mcp/server-card.json`
Documentação Swagger	`https://api.quantoracle.dev/docs`

Início 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

Todas as 63 calculadoras + 10 compostos no seu terminal. Zero dependências.

npm install -g quantoracle-cli

Ou execute sem 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

Plano Gratuito

1.000 chamadas gratuitas por IP por dia. Sem cadastro. Sem chave de API. Basta chamar a API.

	Gratuito	Pago (x402)
Chamadas	1.000/dia	Ilimitado
Autenticação	Nenhuma	Cabeçalho de micropagamento x402
Calculadoras	Todas as 63	Todas as 63
Fluxos de trabalho compostos	Nenhum (somente pago)	Todos os 10
Plano de dados ao vivo	20 chamadas/dia	Pague por chamada
Monitoramento Watch	Teste gratuito de 48h (1 por IP / 30d)	$5 por posição / 30 dias
Cabeçalhos de limite	Sim	Sim

Cada resposta inclui cabeçalhos de limite de taxa para que os agentes possam se autogerenciar:

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

Verifique o uso a qualquer momento:

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

Após 1.000 chamadas, a API retorna 402 Payment Required com um cabeçalho de pagamento x402. Qualquer agente compatível com x402 paga automaticamente e continua:

HTTP/1.1 402 Payment Required
PAYMENT-REQUIRED: <base64-encoded payment instructions>

Plano	Preço	Endpoints
Simples	$0,002	Z-score, APY/APR, Fibonacci, Bollinger, ATR, regra de Taylor, inflação, rendimento real, VP, VF, VPL, CAGR, distribuição normal, índice de Sharpe, preço de liquidação, paridade put-call
Médio	$0,005	Black-Scholes, volatilidade implícita, Kelly, dimensionamento de posição, drawdown, regime, cruzamento, amortização de títulos, carry trade, IRP, PPP, taxa de funding, slippage, vesting, rebalanceamento, TIR, volatilidade realizada, PSR, custo de transação
Complexo	$0,008	Risco de portfólio, árvore binomial, opções de barreira/asiáticas/lookback, spread de crédito, VaR, teste de estresse, regressão, cointegração, Hurst, ajuste de distribuição, paridade de risco
Pesado	$0,015	Monte Carlo, GARCH, otimização de portfólio, análise de cadeia de opções, superfície de volatilidade, curva de rendimento, matriz de correlação
Composto	$0,015-0,10	Estratégia de backtest, varredura de spread, plano de rebalanceamento, otimizador de estratégia de opções, recomendação de hedge, análise de risco completa, avaliação de trade, saúde do portfólio, sinal de pares, classificação de regime (somente pago, sem plano gratuito)

Endpoint de Lote

Execute até 100 cálculos em uma única solicitação HTTP. Uma ida e volta em vez 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}}
    ]
  }'

Retorna todos os resultados em uma única resposta com o preço 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	Pago
Chamadas em lote	1 teste (por tempo de vida)	Ilimitado
Máx. por lote	100	100
Preço	Gratuito	Soma dos preços dos endpoints individuais

O preço do lote é a soma dos preços dos endpoints individuais — sem margem de lucro. Você paga pelos cálculos, a velocidade é gratuita.

QuantOracle Live — dados de mercado atualizados + computação

Cada endpoint acima é matemática pura sobre entradas que você fornece — as 73 calculadoras têm zero dependências de dados, o que as torna determinísticas e armazenáveis em cache. QuantOracle Live é o único plano que traz os dados: você passa um ticker, a API busca dados de mercado atualizados e executa a matemática, para que seu agente nunca precise obter ou manter um feed de dados.

Endpoint	Descrição	Preço
`POST /v1/live/volatility`	Volatilidade realizada (7d/30d/90d) + regime para um ativo cripto, a partir de candles diários atualizados	$0,01
`POST /v1/live/funding-rates`	Taxa de funding perpétuo atual + carry anualizado para um ativo 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", ...}

Precificação: o plano Live é pago desde a primeira chamada — não faz parte do plano gratuito de 1.000/dia das calculadoras (o valor está nos dados atualizados + pipeline, que você não pode replicar com uma biblioteca local). Você recebe 20 chamadas gratuitas por IP por dia para avaliar, depois é liquidado por chamada via x402 (USDC na Base ou Solana). Você paga pela atualização, não pela aritmética.

Os resultados são armazenados em cache no servidor (volatilidade ~5 min, funding ~1 min); se um feed upstream estiver temporariamente indisponível, a API serve o último valor bom sinalizado stale: true, com as_of_age_seconds informando quão atualizada está a resposta.

QuantOracle Watch — monitoramento de posição 24/7

A maioria dos agentes de monitoramento reconstrói o mesmo loop: consultar crypto/liquidation-price + risk/var-parametric em um temporizador, o dia todo. Watch substitui o loop — registre uma posição perpétua de cripto uma vez e um watcher isolado a reavalia a cada ~60 segundos: distância de liquidação ajustada por funding (bandas de aviso/crítico com histerese), inversões de sinal da taxa de funding, mudanças de regime de volatilidade por hora e avisos de expiração. Alertas disparam como webhooks assinados com HMAC (X-QO-Signature, chave = seu token de monitoramento) e são registrados no servidor, então o teste precisa de zero infraestrutura — basta consultar.

Endpoint	Descrição	Preço
`POST /v1/watch/trial`	Monitor gratuito de 48 horas — um por IP a cada 30 dias	Gratuito
`POST /v1/watch/position`	Registre uma posição para 30 dias de monitoramento	$5,00
`POST /v1/watch/extend`	+30 dias (também atualiza um teste; corpo: `{monitor_id, token}`)	$5,00
`PATCH /v1/watch/{id}`	Atualize os parâmetros da posição após adicionar margem / redimensionar / mover	Gratuito
`GET /v1/watch/{id}`	Status ao vivo + histórico de alertas (auth por token)	Gratuito
`DELETE /v1/watch/{id}`	Cancelar	Gratuito

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

Sem chaves de exchange, sem custódia, sem execução — Watch lê dados de mercado públicos e envia webhooks, então o pior modo de falha é um alerta perdido (o heartbeat do watcher é publicado em /health como watcher_heartbeat_age_s). Os alvos de webhook são protegidos contra SSRF e as entregas são repetidas. A economia: um loop DIY consultando a mesma matemática uma vez por minuto além do plano gratuito custa ~$7,20/dia em taxas por chamada vs $5 por 30 dias. Tutorial completo: quantoracle.dev/writing/crypto-liquidation-alerts-for-agents.

Pagamentos x402

QuantOracle usa o protocolo x402 para micropagamentos por chamada. Quando um agente esgota seu plano gratuito (ou chama um composto somente pago), a API retorna uma resposta padrão 402 com instruções de pagamento anunciando tanto Base quanto Solana. Agentes compatíveis com x402 (Coinbase AgentKit, AgentCash, OpenClaw, etc.) lidam com o resto automaticamente:

O agente chama o endpoint, recebe 402 com cabeçalho PAYMENT-REQUIRED listando as redes aceitas
O agente assina uma autorização de transferência USDC sem gás na Base (EIP-3009) ou Solana
O agente reenvia a solicitação com cabeçalho PAYMENT-SIGNATURE
O servidor verifica via facilitador CDP, serve a resposta e liquida on-chain

Sem chaves de API. Sem assinaturas. Sem contas. Apenas matemática e micropagamentos.

Redes Suportadas

Rede	Ativo	Gás	Melhor para
Base mainnet (`eip155:8453`)	USDC (`0x8335...`)	~$0,005/tx	Agentes EVM, ferramentas Coinbase, LangChain, ecossistema Base
Solana mainnet (`solana:5eykt4...`)	USDC (`EPjFWdd5...`)	~$0,0002/tx (pagador de taxas CDP)	Solana Agent Kit, Eliza, bots de alta frequência

Liquidação: Via facilitador da Coinbase Developer Platform (api.cdp.coinbase.com/platform/v2/x402)
Carteira Base: 0xC94f5F33ae446a50Ce31157db81253BfddFE2af6
Carteira Solana: 9biztrXscReJ3Wi8EfkD2gL3WXzYUmzTEohD26Bxp39u
Descoberta: https://api.quantoracle.dev/.well-known/x402 (retorna ambas as redes para cada endpoint)

Teste com 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á disponível como um servidor MCP nativo com 80 ferramentas (63 calculadoras + 11 compostas + 2 endpoints de dados de mercado ao vivo + 3 ferramentas de monitoramento QuantOracle Watch + lote). Funciona com Claude Desktop, Cursor, Windsurf, Smithery e qualquer cliente compatível com MCP.

Instalar via npm

npx quantoracle-mcp

Claude Desktop / Claude Code

Adicione como conector em Configurações, ou adicione a claude_desktop_config.json:

{
  "mcpServers": {
    "quantoracle": {
      "url": "https://mcp.quantoracle.dev/mcp"
    }
  }
}

Ou execute localmente via npx:

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

MCP Remoto (HTTP Streamable)

Conecte-se diretamente ao servidor hospedado — sem necessidade de instalação:

https://mcp.quantoracle.dev/mcp

Smithery

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

OpenClaw / ClawHub

clawhub install quantoracle

Integrações

QuantOracle está disponível em múltiplos ecossistemas de agentes:

Plataforma	Como conectar
Claude Desktop / Claude Code	URL do conector: `https://mcp.quantoracle.dev/mcp`
Cursor / Windsurf	Config MCP: `npx quantoracle-mcp`
Smithery	`npx @smithery/cli mcp add QuantOracle/quantoracle`
OpenClaw / ClawHub	`clawhub install quantoracle`
CLI	`npm install -g quantoracle-cli` ou `npx quantoracle-cli`
Glama	glama.ai/mcp/servers/QuantOracledev/quantoracle
npm (MCP)	`npx quantoracle-mcp`
Ecossistema 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 do servidor — Base + Solana
API REST	`https://api.quantoracle.dev/v1/...`
Especificação OpenAPI	`https://api.quantoracle.dev/openapi.json`
Interface Swagger	`https://api.quantoracle.dev/docs`

Descoberta de Ferramentas

# 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

Referência Completa de Endpoints

Opções (4 endpoints)

Endpoint	Descrição	Preço
`POST /v1/options/price`	Precificação Black-Scholes com 10 Gregas (delta até color)	$0,005
`POST /v1/options/implied-vol`	Solucionador de volatilidade implícita Newton-Raphson	$0,005
`POST /v1/options/strategy`	P&L de estratégias de opções multi-perna, pontos de equilíbrio, lucro/perda máximo	$0,008
`POST /v1/options/payoff-diagram`	Geração de dados de diagrama de payoff de opções multi-perna	$0,005

Derivativos (7 endpoints)

Endpoint	Descrição	Preço
`POST /v1/derivatives/binomial-tree`	Precificação de árvore binomial CRR para opções americanas e europeias	$0,008
`POST /v1/derivatives/barrier-option`	Precificação de opções de barreira usando fórmulas analíticas	$0,008
`POST /v1/derivatives/asian-option`	Precificação de opções asiáticas: forma fechada geométrica ou aproximação aritmética	$0,008
`POST /v1/derivatives/lookback-option`	Precificação de opções lookback (strike flutuante/fixo, Goldman-Sosin-Gatto)	$0,008
`POST /v1/derivatives/option-chain-analysis`	Análise de cadeia de opções: skew, max pain, razões put-call	$0,015
`POST /v1/derivatives/put-call-parity`	Verificação de paridade put-call e detecção de arbitragem	$0,002
`POST /v1/derivatives/volatility-surface`	Construção de superfície de volatilidade implícita a partir de dados de mercado	$0,015

Risco (8 endpoints)

Endpoint	Descrição	Preço
`POST /v1/risk/portfolio`	22 métricas de risco: Sharpe, Sortino, Calmar, Omega, VaR, CVaR, drawdown	$0,008
`POST /v1/risk/kelly`	Critério de Kelly: discreto (ganho/perda) ou contínuo (série de retornos)	$0,005
`POST /v1/risk/position-size`	Dimensionamento de posição fracionária fixa com metas de risco/recompensa	$0,005
`POST /v1/risk/drawdown`	Decomposição de drawdown com curva submersa	$0,005
`POST /v1/risk/correlation`	Matrizes de correlação e covariância N x N a partir de séries de retornos	$0,008
`POST /v1/risk/var-parametric`	Value-at-Risk paramétrico e CVaR condicional	$0,008
`POST /v1/risk/stress-test`	Teste de estresse de portfólio em múltiplos cenários	$0,008
`POST /v1/risk/transaction-cost`	Modelo de custo de transação: comissão + spread + impacto de mercado Almgren	$0,005

Indicadores (6 endpoints)

Endpoint	Descrição	Preço
`POST /v1/indicators/technical`	13 indicadores técnicos (SMA, EMA, RSI, MACD, etc.) + sinais compostos	$0,005
`POST /v1/indicators/regime`	Classificação de tendência + regime de volatilidade + risco composto	$0,005
`POST /v1/indicators/crossover`	Detecção de cruzamento dourado/da morte com histórico de sinais	$0,005
`POST /v1/indicators/bollinger-bands`	Bandas de Bollinger com %B, largura de banda e detecção de squeeze	$0,002
`POST /v1/indicators/fibonacci-retracement`	Níveis de retração e extensão de Fibonacci	$0,002
`POST /v1/indicators/atr`	Average True Range com ATR normalizado e regime de volatilidade	$0,002

Estatísticas (12 endpoints)

Endpoint	Descrição	Preço
`POST /v1/stats/linear-regression`	Regressão linear OLS com R-quadrado, estatísticas t, erros padrão	$0,008
`POST /v1/stats/polynomial-regression`	Regressão polinomial de grau n com métricas de qualidade de ajuste	$0,008
`POST /v1/stats/cointegration`	Teste de cointegração Engle-Granger com razão de hedge e meia-vida	$0,008
`POST /v1/stats/hurst-exponent`	Expoente de Hurst via análise de amplitude reescalonada (R/S)	$0,008
`POST /v1/stats/garch-forecast`	Previsão de volatilidade GARCH(1,1) usando estimativa de máxima verossimilhança	$0,015
`POST /v1/stats/zscore`	Z-scores móveis e estáticos com detecção de valores extremos	$0,002
`POST /v1/stats/distribution-fit`	Ajuste de dados a distribuições comuns e classificação por qualidade de ajuste	$0,008
`POST /v1/stats/correlation-matrix`	Matrizes de correlação e covariância com decomposição de autovalores	$0,015
`POST /v1/stats/realized-volatility`	Volatilidade realizada: close-to-close, Parkinson, Garman-Klass, Yang-Zhang	$0,005
`POST /v1/stats/normal-distribution`	Distribuição normal: CDF, PDF, quantil, intervalos de confiança	$0,002
`POST /v1/stats/sharpe-ratio`	Índice de Sharpe autônomo com erro padrão Lo (2002) e IC de 95%	$0,002
`POST /v1/stats/probabilistic-sharpe`	Índice de Sharpe Probabilístico (Bailey & Lopez de Prado 2012)	$0,005

Portfólio (2 endpoints)

Endpoint	Descrição	Preço
`POST /v1/portfolio/optimize`	Otimização de portfólio: Sharpe máximo, vol mínima ou paridade de risco	$0,015
`POST /v1/portfolio/risk-parity-weights`	Pesos de portfólio de contribuição de risco igual (Spinu 2013)	$0,008

Renda Fixa (4 endpoints)

Endpoint	Descrição	Preço
`POST /v1/fixed-income/bond`	Preço de título, duração Macaulay/modificada, convexidade, DV01	$0,008
`POST /v1/fixed-income/amortization`	Cronograma completo de amortização com análise de economia de pagamentos extras	$0,005
`POST /v1/fi/yield-curve-interpolate`	Interpolação de curva de rendimento: linear, spline cúbico, Nelson-Siegel	$0,015
`POST /v1/fi/credit-spread`	Spread de crédito e Z-spread a partir do preço do título vs curva livre de risco	$0,008

Cripto / DeFi (7 endpoints)

Endpoint	Descrição	Preço
`POST /v1/crypto/impermanent-loss`	Calculadora de perda impermanente para posições AMM Uniswap v2/v3	$0,005
`POST /v1/crypto/apy-apr-convert`	Conversão entre APY e APR com composição configurável	$0,002
`POST /v1/crypto/liquidation-price`	Calculadora de preço de liquidação para posições alavancadas	$0,002
`POST /v1/crypto/funding-rate`	Análise de taxa de funding com anualização e detecção de regime	$0,005
`POST /v1/crypto/dex-slippage`	Estimador de slippage DEX para AMM de produto constante (x*y=k)	$0,005
`POST /v1/crypto/vesting-schedule`	Cronograma de vesting de tokens com cliff, desbloqueio linear/graduado, TGE	$0,005
`POST /v1/crypto/rebalance-threshold`	Analisador de rebalanceamento de portfólio: detecção de desvio e dimensionamento de negociação	$0,005

Dados ao Vivo (2 endpoints) — nível pago, dados de mercado atualizados

Endpoint	Descrição	Preço
`POST /v1/live/volatility`	Volatilidade realizada ao vivo (7d/30d/90d) + regime para um ativo cripto	$0,01
`POST /v1/live/funding-rates`	Taxa de funding perpétuo ao vivo + carry anualizado para um ativo cripto	$0,005

Pago desde a primeira chamada (não faz parte do nível gratuito); 20 chamadas gratuitas/IP/dia. Veja QuantOracle Live.

Watch — monitoramento de posição (6 endpoints)

Endpoint	Descrição	Preço
`POST /v1/watch/trial`	Monitor de teste gratuito de 48 horas (um por IP a cada 30 dias)	Grátis
`POST /v1/watch/position`	Monitoramento 24/7 de uma posição perpétua por 30 dias	$5,00
`POST /v1/watch/extend`	Estender ou atualizar um monitor por 30 dias	$5,00
`PATCH /v1/watch/{id}`	Atualizar parâmetros de posição (direção/entrada/tamanho/colateral/mmr/webhook/limiares)	Grátis
`GET /v1/watch/{id}`	Status ao vivo + histórico de alertas (autenticação por token)	Grátis
`DELETE /v1/watch/{id}`	Cancelar um monitor	Grátis

Preço por monitor, não por chamada. Veja QuantOracle Watch.

FX / Macro (7 endpoints)

Endpoint	Descrição	Preço
`POST /v1/fx/interest-rate-parity`	Calculadora de paridade de taxa de juros com detecção de arbitragem	$0,005
`POST /v1/fx/purchasing-power-parity`	Estimativa de valor justo de paridade do poder de compra	$0,005
`POST /v1/fx/forward-rate`	Bootstrap de taxas a termo a partir de uma curva de rendimento à vista	$0,005
`POST /v1/fx/carry-trade`	Decomposição de P&L de carry trade de moedas	$0,005
`POST /v1/macro/inflation-adjusted`	Conversão de retornos nominais para reais usando a equação de Fisher	$0,002
`POST /v1/macro/taylor-rule`	Prescrição de taxa de juros pela Regra de Taylor	$0,002
`POST /v1/macro/real-yield`	Rendimento real e inflação de equilíbrio a partir de rendimentos nominais	$0,002

Valor do Dinheiro no Tempo (5 endpoints)

Endpoint	Descrição	Preço
`POST /v1/tvm/present-value`	Valor presente de um montante fixo futuro e/ou fluxo de anuidade	$0,002
`POST /v1/tvm/future-value`	Valor futuro de um montante fixo presente e/ou fluxo de anuidade	$0,002
`POST /v1/tvm/irr`	Taxa interna de retorno via Newton-Raphson	$0,005
`POST /v1/tvm/npv`	Valor presente líquido com índice de lucratividade e período de payback	$0,002
`POST /v1/tvm/cagr`	Taxa de crescimento anual composta com projeções futuras	$0,002

Simulação (1 endpoint)

Endpoint	Descrição	Preço
`POST /v1/simulate/montecarlo`	Monte Carlo GBM com contribuições/retiradas, até 5000 caminhos	$0,015

Endpoints Compostos (somente pagos)

Endpoints de nível superior que combinam múltiplos cálculos em uma única chamada. Mesma matemática dos endpoints individuais — apenas empacotados para fluxos de trabalho comuns de agentes. Sem nível gratuito.

Endpoint	Descrição	Substitui	Preço
`POST /v1/backtest/strategy`	Executar backtest de cruzamento SMA, reversão à média RSI, momentum ou breakout de Bollinger	10+ chamadas de indicador + risco	$0,10
`POST /v1/options/spread-scan`	Escanear e classificar spreads verticais por risco/recompensa	8-16 chamadas de opções/preço	$0,05
`POST /v1/portfolio/rebalance-plan`	Gerar lista de negociações para atingir pesos-alvo com estimativa de custo	portfólio/otimizar + custo de transação	$0,05
`POST /v1/options/strategy-optimizer`	Classificar as melhores estratégias de opções dado cenário + visão de volatilidade	opções/estratégia + diagrama de payoff	$0,08
`POST /v1/hedging/recommend`	Classificar hedges efetivos mais baratos (put protetor, collar, futuros, parcial)	opções/preço + Gregas	$0,04
`POST /v1/risk/full-analysis`	Relatório completo de risco: Sharpe, Sortino, VaR, Kelly, drawdown, Hurst, CAGR	7 chamadas individuais	$0,04
`POST /v1/portfolio/health`	Verificação de saúde do portfólio: risco, correlação, rebalanceamento, teste de estresse	6 chamadas individuais	$0,04
`POST /v1/trade/evaluate`	Avaliação de negociação: dimensionamento, risco/recompensa, Kelly, custos, regime, sinais, veredito	5 chamadas individuais	$0,025
`POST /v1/pairs/signal`	Sinal de negociação de pares: cointegração, Hurst, z-score, meia-vida, razão de hedge	4 chamadas individuais	$0,025
`POST /v1/indicators/regime-classify`	Tendência, regime de vol, RSI, direção, sugestão de estratégia	técnico + regime + vol realizada	$0,015

Exemplo: Fluxo de Trabalho de Backtest de Agente

Um backtest típico de agente encadeia múltiplas chamadas QuantOracle por iteração:

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 chamada é uma calculadora pura — sem estado, sem efeitos colaterais, sem chaves de API.

Otimizador de Estratégia (mais de 1.200 chamadas)

examples/strategy_optimizer.py é um otimizador de parâmetros walk-forward completo que demonstra uso intenso da API:

Fase	O que faz	Chamadas de API
Varredura de Parâmetros	Testa 180 combinações de lookback/rebalance/RSI em 8 ativos	~1.080
Análise Profunda	22 métricas de risco + VaR + Kelly + Monte Carlo nas 3 principais configurações	~60-80
Sobreposição de Opções	Precifica covered calls em 6 ativos x 4 vencimentos x 5 strikes	~100-150
Análise de Pares	Varredura de cointegração + expoente de Hurst em 45 pares de ativos	~50-70

pip install requests
python examples/strategy_optimizer.py

Uma única execução faz cerca de 1.200-1.500 chamadas de API. Nas tarifas pagas, isso custa cerca de US$ 6-8 USDC. Os mesmos cálculos feitos por um LLM em contexto custariam US$ 12-60 em tokens (de Sonnet a Opus), levariam 4x mais tempo e errariam 15-30% da matemática complexa.

Auto-hospedagem

# 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

Precisão

Cada endpoint é testado contra soluções analíticas publicadas:

120 benchmarks com citações (Hull, Wilmott, Bailey & Lopez de Prado, Goldman-Sosin-Gatto, Taylor, Fisher, Markowitz)
Mais de 65 testes de integração cobrindo todas as 63 calculadoras
Matemática pura em Python — sem numpy/scipy, zero dependências nativas
Determinístico: as mesmas entradas sempre produzem as mesmas saídas

Execute você mesmo a suíte de verificação:

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

Arquitetura

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 na Base e Solana

Licença

MIT — use o QuantOracle como quiser.