The server provides live AI compute pricing data, cost estimation, and Claude Code session cost analysis.
Oracle data tools: fetch current model prices (base/billed), SCU index, breakdowns, CPI, reconstitutions, methodology, history, per-model price history, catalog, price at a timestamp, baseline, SCU at a timestamp, and model availability.
Compute tools: estimate cost for a model given token counts, and compare costs across all index models for a workload.
Render tools: produce pre-formatted session cost reports, per-inference breakdowns, and active session tables for Claude Code skills.
Analysis tools: return raw JSON session analysis and per-inference breakdowns for custom UIs.
Telemetry tool: aggregate stats across logged sessions (cumulative cost, medians, insights).
Account integration: optional connection to your Compute Finance account adds account tools (balance, keys, limits) via app grant.
All read-only: no API key required for public data; local transcript analysis stays on your machine.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@@compute-finance/mcp compare GPT-4o and Claude 3.5 Sonnet pricing"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Live AI compute pricing oracle — real-time LLM model prices across nine vendors (Anthropic, OpenAI, Google, DeepSeek, xAI and four more) via the Compute Finance Oracle.
A stdio MCP server. Works in any MCP client. Includes optional Claude Code skills for session cost analysis.
npx @compute-finance/mcp setupThis single command:
Registers the MCP server at user scope (claude mcp add)
Installs Claude Code skills (/cf-session-management, /cf-session-consumption, /cf-active-sessions, /cf-account)
Installs the cost hook — a UserPromptSubmit hook that injects session cost into Claude's context so every response can show how much you've spent
Restart Claude Code after setup.
To also answer for your own Compute Finance account, connect it once — see Your account.
Or register manually without skills/hook:
claude mcp add --scope user compute-finance -- npx @compute-finance/mcpAdd to your MCP config (.cursor/mcp.json, VS Code settings, etc.):
{
"mcpServers": {
"compute-finance": {
"command": "npx",
"args": ["@compute-finance/mcp"]
}
}
}git clone https://github.com/compute-finance/mcp.git
cd mcp
npm install && npm run build
npx . setupRelated MCP server: ohmytoken
Tools are named by layer prefix and come in three groups. The public and local groups need no API key and no account.
Group | Prefixes | What the tools touch |
Public data |
| Read the live Compute Finance Oracle over unauthenticated GETs |
Local sessions |
| Read Claude Code transcripts on this machine, price them at live oracle rates, and append the measurements to the session logs under |
Your account |
| Registered only once an app grant is connected, and only the tools that grant allows. With Read access they read the account's balance, spend, keys and history; with Act access some of them act on the account — create an API key, freeze or unfreeze a key, set budget caps, configure auto top-up |
The account_* tools are not listed below: the exchange publishes them, and this package copies none of them. See Your account.
Tool | Description |
| Every model in the current SCU index, with provider, family (e.g. |
| Price for a single model (e.g. |
| Current Standard Compute Unit — value plus a methodology-versioned |
| Per-family blended-cost breakdown alone — methodology-versioned discriminated union with one entry per family representative |
| Full Compute Price Index as last attested on-chain — |
| Historical index changes — model swaps, SCU before/after |
| Methodology changelog — every version with its formula summary and spec link, plus the version in force |
| SCU index time series over a date range — |
| Per-model input/output USD price time series for any oracle-tracked model — same granularity semantics as |
| Every model with a recorded price, index members and non-index entries alike — |
| Per-model input/output USD price effective at a timestamp — |
| Frozen SCU denominator behind |
| SCU value active at a timestamp via step function — no interpolation, |
| Which models can serve right now — every catalogue model with a |
Models are identified by their canonical vendor-prefixed id — anthropic/claude-opus-4.8, openai/gpt-5.5, qwen/qwen-3.5-flash. Every tool taking a model also accepts the bare name (gpt-5.5) and answers with the canonical id. The vendor slug is not always the provider key (alibaba → qwen, xai → x-ai, moonshot → moonshotai), so reuse an id the API returned rather than assembling one. data_get_scu, data_get_breakdown and data_get_reconstitutions are the exception: they pass the attested manifest through verbatim and so report bare model keys, because a / is not a legal manifest key.
Cache pricing comes from the Compute Finance Oracle. Session and consumption reports show effective (cache-aware) cost when the oracle has published the relevant cache components; otherwise they show nominal cost (input rate applied to every input variant) and label effective as unavailable for that model.
Alongside cache, the oracle publishes a reasoning output price — reasoning.reasoningOutput, on the same base as every other component; the whole reasoning block is null for a model with no usable reasoning price. It is catalogue data. Session and consumption reports do not bill it: Claude Code transcripts count thinking blocks rather than reasoning tokens, and those tokens are already inside output_tokens.
Every price is reported on two bases: base_* is the provider list price, identical for every model the oracle tracks, and billed_* is what compute.finance charges — base × (1 + routing_fee_rate). Compare models on base_*, budget on billed_*. The rate ships once per response and billed_* is null when the oracle does not publish it. Session and consumption reports are on the base basis throughout.
Every current-price answer comes from one place: the live catalogue the exchange bills against. Index membership decides which models data_get_basket and compute_compare list, never what a model costs, so two models the catalogue prices alike quote alike. data_get_cpi is the exception by design — it serves the prices the latest on-chain revision attested, which change only when an operator publishes the next one and may therefore lag the catalogue. Read it as attestation history, not as a quote.
Some models get pricier past a context length. data_get_basket and data_get_price publish that as context_tiers, a ladder ascending by from_input_tokens and always at least one rung: the first starts at 0 and restates the flat rate, so a model priced the same at every size has exactly one rung and nothing has to branch on whether a model happens to be tiered. Rungs carry base_* and billed_* like every other price; only the flat rate enters the SCU index. compute_estimate and compute_compare pick the rung from the whole input side of the request — prompt plus cache reads plus cache writes, all charged at the full input rate there since neither tool applies a cache discount — over half-open ranges, so an input landing exactly on a threshold takes that rung, and both return the chosen rung as applied_context_tier so the rate behind the number is visible. data_get_catalog passes the oracle document through unchanged, so there contextTiers is absent rather than one-rung on a flat model.
The ladder comes from the catalog endpoint, and the two kinds of tool part ways whenever it cannot answer for a model — the read failed, or it succeeded and the model was not in it, which is upstream drift rather than a flat price. data_get_basket and data_get_price still serve their prices and set context_tiers to null — an unknown ladder, never a one-rung stand-in for a ladder nobody read. compute_estimate and compute_compare error instead: a cost quoted at the flat rate would understate exactly the long context the ladder exists to price.
max_input_tokens is the largest input a model accepts, null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the oracle refuses the request outright, so compute_estimate and compute_compare set exceeds_max_input_tokens. They still quote the cost: these tools are read-only and an agent sizing a context needs the number before it reshapes the request, but the flag says plainly that the request as supplied would be rejected.
Prices also carry a provenance mark saying how far the number has been checked: verified — an operator recorded a vendor source for it; inferred — derived from a sibling number or a vendor default, with no source recorded; promotional — a discounted list price that is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor. Every cache and reasoning component carries its own mark wherever it appears, and so does every base price: data_get_catalog marks currentPrice.provenance for every model, index member or not, while data_get_basket, data_get_price and compute_estimate carry the same pair as base_price_provenance. A rung follows the same rule: the first repeats the base price's mark, and a higher rung is always a catalogue number, marked in both directions with the single mark the vendor quotes it under. Session and consumption reports print each cache multiplier with its mark; when the oracle publishes no cache pricing for a model they say so and print no marks.
A price says what a model costs, never whether it can serve. data_get_model_availability answers that second question: the public pool's routability list — every catalogue model under its canonical id with a routable flag, plus the model auto points at. Call it before settling on a model, so one that cannot serve is ruled out before the request instead of by a 503 after it. The signal is advisory: true as of computedAt and only for ttlSeconds after it, capacity moves on its own, and a model reported routable can still fail the send — the caller still handles the error on the request itself. The answer is the exchange's own, served verbatim with no liveness computed here, so it cannot disagree with the router that has to honour it; it is cached for exactly the ttlSeconds published with it, and not at all when that figure is missing or unusable, rather than for the window every other read uses.
Private offers are not listed. A model a supplier offers to a private pool, under a handle/alias id, never enters the public catalogue: it is listed only once the pool's owner accepts the offer, and then only to API keys bound to that pool — and this server sends no such key, with or without a connected account. To see them, call GET /v1/models with a ct_live_* key bound to the pool.
Tool | Description |
| Nominal USD cost for a model given input/output token counts — |
| Rank every model in the current SCU index by cost for a workload, grouped by family — the same three cost figures per row, each on that model's own rung |
Tool | Description |
| Pre-formatted session cost report — used by |
| Pre-formatted per-inference breakdown — used by |
| Overview of recent sessions across projects — used by |
Reports surface three orthogonal counts: prompts (what you typed), inferences (assistant replies — tool-loop sessions produce several per prompt), and tool calls (tool_use blocks). The triplet is identical across all three reports for the same session.
Tool | Description |
| Raw JSON session analysis (for custom UI, not skills) |
| Raw JSON per-inference breakdown (for custom UI, not skills) |
The analyze_session counterfactual quotes each model's base rate and never a long-context rung. A rung is picked per request, and a session's summed input is not one giant request — a hundred 5k-token calls are not a single 500k-token one — so pricing the total on a higher rung would overcharge. Expect those rows to sit below compute_compare for a model that gets pricier past a context length.
Tool | Description |
| Aggregate stats across logged sessions — cumulative cost, per-profile medians, insights |
Everything above is public data or local files. To ask what your Compute Finance account has spent, which of your keys are live, or how much headroom is left before a cap, connect the account with an app grant.
In compute.finance open Settings → Connected apps, press Grant access, name the app and choose what it may do: Read (see the account's balance, usage and history) and/or Act (manage the account's keys and limits). If you work in an organization, pick the account the grant acts on — the grant is pinned to it and no session elsewhere can redirect it.
Copy the cfa_live_… token. It is shown once.
Store it:
npx @compute-finance/mcp setup --accountSetup asks for the token on stdin — typing is hidden, and the token is never an argument, so it cannot land in your shell history or in an MCP config file. It is then stored in the credential store your OS already ships: macOS Keychain (security), Windows DPAPI (a blob under %APPDATA% only your Windows user can decrypt), or the Secret Service on Linux (secret-tool, from libsecret). No native npm dependency is added for any of them.
Setup checks the token with the exchange before storing it: a token the exchange refuses is not stored. If the exchange cannot be reached, setup warns and stores the token anyway, so a token typed while offline is checked on the server's first start instead. On a system with none of these stores, setup stores nothing and points you at CF_APP_GRANT_COMMAND (below).
Restart your MCP client. The account_* tools appear; with no credential they are simply not registered and the oracle and session tools behave exactly as before.
At startup, in this order, stopping at the first that answers:
Source | Use |
| A shell command that prints the token on stdout — |
OS credential store | What |
| The environment. Intended for CI, where no interactive store exists. |
Wherever it came from, the token is only ever sent to an https origin — or to http on a loopback host, so a local API still works. CF_API_BASE pointing anywhere else is refused at startup and the token is not sent.
A grant is limited to the operations you ticked when you created it, on the one account you pinned it to. It can never take money out of the account — no withdrawal, no transfer, and no action that needs a wallet signature. Those stay with your wallet.
Act access is not harmless. An app holding it can create an API key that spends the account's balance, change or clear the budget caps that bound that spending, and configure automatic top-up. Automatic top-up always applies to your own personal account, even when the grant is pinned to an organization. Tick Act only for an app you would trust with those three; grant Read alone otherwise.
The exchange decides what each grant may call. GET /v1/account-tools returns only the tools that grant holds the access for, with their descriptions and input schemas; a call goes through POST /v1/account-tools/call. This package copies none of those contracts, so a change on the exchange's side reaches you without a release here.
A refusal is a refusal. When the exchange declines — the grant is frozen, revoked, or lacks the access a tool needs — the tool returns the exchange's own wording naming what is missing. It is never rewritten into an empty balance, an empty key list or a guess. A grant refused at startup registers a single account_status tool carrying that wording, rather than reporting no account at all.
Revoking is done where the grant was made: Settings → Connected apps → Revoke. Revocation is permanent and takes effect at once; your own session and every other app are unaffected. Freeze suspends a grant instead, and can be lifted.
Remove the local copy of the token afterwards:
npx @compute-finance/mcp setup --forget-accountThis clears the OS credential store only. A token supplied through CF_APP_GRANT_COMMAND or CF_APP_GRANT lives wherever you put it; remove it there.
The setup command installs a UserPromptSubmit hook into ~/.claude/settings.json. Every time you send a message, the hook reads the current session transcript, prices it against the live oracle, and injects a cost summary into Claude's context via additionalContext. Claude then appends a 💰 Compute.Finance · … line at the end of its response.
Guards — the hook fires only when all three conditions are met:
Session cost exceeds $1
Session has at least 5 user prompts
At least 10 minutes since the last fire (per session)
On any failure (oracle down, transcript missing, parse error) the hook exits silently — it never blocks your prompt.
If setup can't write to settings.json, add the hook manually:
{
"hooks": {
"UserPromptSubmit": [
{
"matcher": "",
"hooks": [
{
"type": "command",
"command": "npx @compute-finance/mcp hook-prompt"
}
]
}
]
}
}Remove the UserPromptSubmit entry from ~/.claude/settings.json.
All data stays on your machine. Without a connected account the only network calls are unauthenticated GETs to api.compute.finance — the oracle endpoints under /v1/oracle/* and the OpenAPI document at /openapi.json, read once at startup to document oracle response shapes. Session logs (~/.compute-finance/sessions.jsonl, ~/.compute-finance/inferences.jsonl) are never uploaded.
With an account connected, the grant token is sent to api.compute.finance as an Authorization: Bearer header on /v1/account-tools and /v1/account-tools/call, and nowhere else. It is never written to a config file, never passed as a process argument, and never printed to stdout, stderr or a tool answer — including in diagnostics, which are redacted before they are written. Session logs still carry only local measurements and are still never uploaded.
Raw JSON per-inference breakdown — token counts, tool usage, effective/nominal cost, cache hit ratio, duration per inference. One row per assistant reply. inferences[].effective_usd is null when the oracle has not published cache pricing for the model; nominal_usd stays populated as an upper-bound. Source: local Claude Code transcript + Oracle API. For pre-formatted output use render_consumption_report. Omit session_id for the most recent session.
Inputs: cwd, session_id.
Raw JSON session analysis — token totals, effective/nominal cost with cache breakdown, counterfactual across every model in the current SCU index, profile classification. current_model_cost is on the base (provider list) basis, stated in current_model_cost_basis; counterfactual_nominal rows carry base_usd_cost and billed_usd_cost, so the session and the counterfactual are directly comparable on base. Counterfactual rows quote each model's base rate and never a long-context rung: a rung is picked per request, and a session's summed input is not one giant request, so pricing the total on a higher rung would overcharge — expect these rows to sit below compute_compare for a model that gets pricier past a context length. usage.prompts counts user messages, usage.inferences counts assistant replies, usage.tool_calls counts tool_use blocks. current_model_cost.effective_usd is null when the oracle has not published cache pricing for the model; nominal_usd stays populated as an upper-bound. Source: local Claude Code transcript + Oracle API. For pre-formatted output use render_session_report. Omit session_id for the most recent session.
Inputs: cwd, session_id.
Rank every model in the current SCU index by nominal cost for a workload. Source: Oracle API (/v1/oracle/catalog). Cache reads and cache writes belong inside input_tokens and are charged at the full input rate here; no cache discount is applied. Each row carries base_usd_cost (provider list price), routing_fee_usd and billed_usd_cost (what compute.finance charges); ranking is by base_usd_cost, and since the routing fee is one global rate the order is identical on either basis. Every row is priced at the rung input_tokens selects on that model's own ladder, returned whole as applied_context_tier, so a model that gets pricier past a threshold ranks where it truly lands at this size; for every rung read context_tiers on data_get_basket. Rows also carry max_input_tokens and exceeds_max_input_tokens — a row flagged true is still priced and still ranked, but that model would refuse the request. A long-context price ladder ascends by from_input_tokens and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on from_input_tokens takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} provenance pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. max_input_tokens is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. A catalogue that cannot be read, or that does not list the model, errors this tool instead of quoting, because a cost silently computed at the flat rate would understate the long context the ladder exists to price. Returns the sorted list plus a grouping by family (e.g. openai.gpt, anthropic.claude). Covers index members only — for any other tracked model use compute_estimate, whose numbers are on the same basis. Use to answer 'which model is cheapest?' or 'how much would this cost on a different model?'.
Inputs: input_tokens (required), output_tokens (required).
Nominal USD cost for any oracle-tracked model given input/output token counts — index members and catalog-only models on identical terms. Cache reads and cache writes belong inside input_tokens and are charged at the full input rate here; no cache discount is applied. Returns base_usd_cost (provider list price), routing_fee_usd and billed_usd_cost (what compute.finance charges), plus the routing_fee_rate they derive from. Compare models on base_usd_cost; budget on billed_usd_cost. A provenance mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. base_price_provenance marks the input and output prices this cost is built from, populated for every tracked model. The cost is quoted at the rung input_tokens selects on the model's ladder, returned whole as applied_context_tier so the rate behind the number is visible; for every rung read context_tiers on data_get_price. A long-context price ladder ascends by from_input_tokens and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on from_input_tokens takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} provenance pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. max_input_tokens is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. A catalogue that cannot be read, or that does not list the model, errors this tool instead of quoting, because a cost silently computed at the flat rate would understate the long context the ladder exists to price. exceeds_max_input_tokens is true when input_tokens is above max_input_tokens: the cost is still quoted, because a refused request is worth pricing before you reshape it, but the request as supplied would be rejected. price_source ('oracle-basket' | 'oracle-catalog') names the serving endpoint only and does not change the pricing basis, so two models with the same provider price return the same cost. Reasoning tokens are billed inside output_tokens, so this estimate adds no separate reasoning leg; read the model's reasoning price from data_get_price. Errors with 'Model not tracked by oracle' for unknown keys. Source: Oracle API (/v1/oracle/resolve + /v1/oracle/catalog). For a cost with the cache discount applied, use analyze_session on a real transcript. Models are identified by their canonical vendor-prefixed id ('anthropic/claude-sonnet-4.6', 'openai/gpt-5.5'); the bare name ('gpt-5.5') resolves to the same model, and the response echoes the canonical id. The vendor slug is not always provider.key (alibaba → qwen, xai → x-ai, moonshot → moonshotai), so pass an id the API returned rather than assembling one.
Inputs: model (required), input_tokens (required), output_tokens (required).
Frozen SCU denominator for the inverse computeIndex purchasing-power view: the SCU of the first confirmed revision (methodologyVersion 1), captured set-once and never changes. Source: Oracle API (/v1/oracle/baseline). The published computeIndex on /v1/oracle/scu, /v1/oracle/latest and each /v1/oracle/history point equals (baseline.scuUsd / point.scuUsd) × 100 — 100 at genesis, rises as compute gets cheaper. Returns null until the first revision is confirmed.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"date":{"type":"string"},"scuUsd":{"type":"number"},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true}},"required":["date","scuUsd","methodologyVersion"]}
Inputs: no named parameters.
Every model in the current SCU index — provider, family (e.g. openai.gpt, anthropic.claude, google.gemini, xai.grok), base_* USD prices per million tokens (the provider list price), billed_* prices (what compute.finance charges), per-component cache pricing (cachedInput, cacheWrite5m, cacheWrite1h) and a reasoning block carrying reasoningOutput (the whole block is null when the model has no reasoning price), all priced on the same base. routing_fee_rate ships once at the top level; billed_* is null when the oracle does not publish it. Compare models on base_*; budget on billed_*. A provenance mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. base_price_provenance carries one mark for base_input and one for base_output, and every cache and reasoning component carries its own. context_tiers carries each model's long-context price ladder. A long-context price ladder ascends by from_input_tokens and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on from_input_tokens takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} provenance pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. max_input_tokens is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. context_tiers is null — never a one-rung ladder — when the catalogue cannot be read or does not list the model, so an unknown ladder is never served as a flat price; max_input_tokens is null alongside it. Prices are the live catalogue figures the exchange bills, identical to what data_get_price serves for the same model: index membership decides which models are listed here, never what they cost. For the prices a published index revision attested on-chain — which may lag the catalogue — use data_get_cpi. Source: Oracle API (/v1/oracle/catalog). For a single model, use data_get_price instead.
Inputs: no named parameters.
Per-family blended-cost breakdown of the SCU — methodology-versioned discriminated union (keyed by methodologyVersion) with one entry per family representative (family, modelKey, inputPriceUsdPerMillion, outputPriceUsdPerMillion, blendedCostUsd). modelKey is the bare manifest key ('claude-opus-4.8'), not the canonical vendor-prefixed id — strip the vendor prefix off a catalog modelKey before joining on it. Source: Oracle API (/v1/oracle/scu.breakdown). Use to attribute SCU contributions to specific model families. For the full SCU response with reference workload, use data_get_scu instead.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"scuUsd":{"type":"number"},"computeIndex":{"type":"number","nullable":true},"referenceWorkload":{"type":"object","properties":{"inputTokens":{"type":"number"},"outputTokens":{"type":"number"}}},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"breakdown":{"oneOf":[{"type":"object","properties":{"methodologyVersion":{"type":"number","minimum":1,"maximum":1},"familyRepresentatives":{"type":"array","items":{"type":"object","properties":{"family":{"type":"string"},"modelKey":{"type":"string"},"inputPriceUsdPerMillion":{"type":"number"},"outputPriceUsdPerMillion":{"type":"number"},"blendedCostUsd":{"type":"number"}},"required":["family","modelKey","inputPriceUsdPerMillion","outputPriceUsdPerMillion","blendedCostUsd"]}}},"required":["methodologyVersion","familyRepresentatives"]}]},"updatedAt":{"type":"string"}},"required":["scuUsd","computeIndex","referenceWorkload","methodologyVersion","breakdown","updatedAt"]}
Inputs: no named parameters.
Full catalog of tracked models — every model with a recorded price, including non-index entries. Source: Oracle API (/v1/oracle/catalog). Each entry carries modelKey (the canonical vendor-prefixed id, e.g. 'anthropic/claude-opus-4.8'), displayName, provider, family, indexMember flag (true if current family representative in the latest confirmed revision), currentPrice with input/output USD per million tokens and an observedAt timestamp, and per-component cache/reasoning blocks (reasoning is null when the model has no reasoning price). A provenance mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. currentPrice.provenance carries one mark per price for every model, index member or not, because these are catalogue rows rather than manifest figures; every cache and reasoning component carries its own. This tool passes the oracle document through unchanged, so its long-context fields keep the upstream shape: contextTiers is an ascending array of rungs above the flat rate, absent entirely on a model priced the same at every input size, and each rung carries one provenance mark covering both its directions; maxInputTokens is absent on a model that declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. For the same ladder normalised so a flat model needs no special case, use data_get_price or compute_estimate. For basket-only display, use data_get_basket instead.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"models":{"type":"array","items":{"type":"object","properties":{"modelKey":{"type":"string"},"displayName":{"type":"string"},"provider":{"type":"object","properties":{"key":{"type":"string","enum":["openai","anthropic","google","xai","moonshot","alibaba","deepseek","minimax","xiaomi"],"x-enumNames":["OpenAI","Anthropic","Google","XAI","Moonshot","Alibaba","DeepSeek","MiniMax","Xiaomi"]},"name":{"type":"string"}},"required":["key","name"]},"sdkId":{"description":"The id this model answers to at its own vendor. It differs from the name in modelKey wherever the vendor spells its model differently (claude-opus-5.5 is claude-opus-5-5 upstream), and it is what a request to this model carries out to the vendor.","type":"string"},"family":{"type":"string","nullable":true},"indexMember":{"description":"Whether this model is the current family representative in the latest confirmed SCU revision.","type":"boolean"},"releasedAt":{"type":"string","format":"date-time","nullable":true},"maxInputTokens":{"description":"Largest input, in tokens, this model accepts. A request estimated above it is refused with 422 before it reaches the provider. Absent means the model declares no window of its own and only the request-body ceiling applies.","type":"integer","minimum":0,"exclusiveMinimum":true},"currentPrice":{"type":"object","properties":{"inputPriceUsdPerMillion":{"type":"number"},"outputPriceUsdPerMillion":{"type":"number"},"provenance":{"type":"object","properties":{"input":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"output":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]}},"required":["input","output"]},"observedAt":{"type":"string","format":"date-time"}},"required":["inputPriceUsdPerMillion","outputPriceUsdPerMillion","provenance","observedAt"]},"contextTiers":{"description":"Long-context price ladder, ascending by fromInputTokens, present only on models that carry one. currentPrice is the flat rate below the first threshold and is the only price the SCU manifest attests; a request above a threshold is billed at that tier instead. Absent means the model costs the same at every input size.","type":"array","items":{"type":"object","properties":{"fromInputTokens":{"description":"Lowest input size, in tokens, priced at this tier. The tier is selected from the whole input side of a request — prompt plus cache reads plus cache writes — and the range is half-open, so an input landing exactly here takes this tier rather than the one below.","type":"integer","minimum":0,"exclusiveMinimum":true},"inputPriceUsdPerMillion":{"type":"number"},"outputPriceUsdPerMillion":{"type":"number"},"provenance":{"description":"One mark for the band: a tier is quoted by the vendor as a single line, so its input and output share it. A band may be marked differently from the model's flat price.","type":"string","enum":["verified","inferred","promotional"]}},"required":["fromInputTokens","inputPriceUsdPerMillion","outputPriceUsdPerMillion","provenance"]}},"cache":{"type":"object","properties":{"cachedInput":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true},"cacheWrite5m":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true},"cacheWrite1h":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true},"read_multiplier":{"type":"number","nullable":true},"write_multiplier_5m":{"type":"number","nullable":true},"write_multiplier_1h":{"type":"number","nullable":true}},"required":["cachedInput","cacheWrite5m","cacheWrite1h","read_multiplier","write_multiplier_5m","write_multiplier_1h"],"nullable":true},"reasoning":{"type":"object","properties":{"reasoningOutput":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true}},"required":["reasoningOutput"],"nullable":true}},"required":["modelKey","displayName","provider","sdkId","family","indexMember","releasedAt","currentPrice","cache","reasoning"]}},"truncated":{"type":"boolean"},"generatedAt":{"type":"string","format":"date-time"}},"required":["models","truncated","generatedAt"]}
Inputs: no named parameters.
Full Compute Price Index — raw oracle response with the canonical vendor-prefixed model id, provider, family, raw and marked-up prices, scuUsd, revisionVersion, last-updated timestamp. The prices are the figures the latest published revision attested on-chain: they change only when an operator publishes a new revision, so they may lag the live catalogue and must not be quoted as what a model costs now — for that use data_get_price or data_get_basket. Source: Oracle API. Use this for the complete index data as attested. For the per-family blended-cost breakdown, use data_get_breakdown.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"models":{"type":"array","items":{"type":"object","properties":{"id":{"type":"string"},"displayName":{"type":"string"},"provider":{"type":"object","properties":{"key":{"type":"string"},"name":{"type":"string"}},"required":["key","name"]},"family":{"description":"Provider product line (e.g. 'openai.gpt'). One family per basket slot; the latest released model in the family is the representative.","type":"string"},"weiPricePerMillion":{"type":"object","properties":{"input":{"type":"number"},"output":{"type":"number"}},"required":["input","output"]},"usdPricePerMillion":{"type":"object","properties":{"input":{"type":"number"},"output":{"type":"number"}},"required":["input","output"]},"markedUpWeiPricePerMillion":{"type":"object","properties":{"input":{"type":"number"},"output":{"type":"number"}},"required":["input","output"]},"markedUpUsdPricePerMillion":{"type":"object","properties":{"input":{"type":"number"},"output":{"type":"number"}},"required":["input","output"]},"releasedAt":{"type":"string","format":"date-time","nullable":true},"cache":{"type":"object","properties":{"cachedInput":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true},"cacheWrite5m":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true},"cacheWrite1h":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true},"read_multiplier":{"type":"number","nullable":true},"write_multiplier_5m":{"type":"number","nullable":true},"write_multiplier_1h":{"type":"number","nullable":true}},"required":["cachedInput","cacheWrite5m","cacheWrite1h","read_multiplier","write_multiplier_5m","write_multiplier_1h"],"nullable":true},"reasoning":{"type":"object","properties":{"reasoningOutput":{"type":"object","properties":{"usdPerMillion":{"type":"number","nullable":true},"ratioOfInput":{"type":"number","nullable":true},"source":{"type":"string"},"sourceUrl":{"type":"string","nullable":true},"provenance":{"description":"How far this number has been checked. 'verified' — an operator recorded a vendor source for this number; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price that bills exactly as shown and is expected to end. Every value bills as shown; the mark says how much to trust it, not what it costs. Marks are set by hand and hold as of the operator's last pass, not as a live check against the vendor: a number that went on promotion and has not been re-marked still reads as it was.","type":"string","enum":["verified","inferred","promotional"]},"createdAt":{"type":"string","nullable":true}},"required":["usdPerMillion","ratioOfInput","source","sourceUrl","provenance","createdAt"],"nullable":true}},"required":["reasoningOutput"],"nullable":true}},"required":["id","displayName","provider","family","weiPricePerMillion","usdPricePerMillion","markedUpWeiPricePerMillion","markedUpUsdPricePerMillion","releasedAt","cache","reasoning"]}},"scuUsd":{"type":"number"},"routingFeeRate":{"type":"number"},"revisionVersion":{"type":"number","nullable":true},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true,"nullable":true},"lastUpdated":{"type":"string"}},"required":["models","scuUsd","routingFeeRate","revisionVersion","methodologyVersion","lastUpdated"]}
Inputs: no named parameters.
SCU index time series — date-range history of Standard Compute Unit values with optional bucketing granularity. Source: Oracle API (/v1/oracle/history). Each point carries scuUsd, methodologyVersion, revisionVersion, metadataHash, and computeIndex when populated. per-revision emits one point per revision; daily and weekly buckets carry the last revision's value forward across empty buckets (step-function close). Defaults to per-revision over the full range. For a single point at a specific timestamp, fetch the individual revision via data_get_cpi.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"from":{"type":"string"},"to":{"type":"string"},"granularity":{"type":"string","enum":["per-revision","daily","weekly"]},"count":{"type":"integer","minimum":0,"exclusiveMinimum":false},"truncated":{"type":"boolean"},"data":{"type":"array","items":{"type":"object","properties":{"date":{"type":"string"},"scuUsd":{"type":"number"},"computeIndex":{"type":"number","nullable":true},"revisionVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"metadataHash":{"type":"string","pattern":"^0x[0-9a-f]{64}$"}},"required":["date","scuUsd","computeIndex","revisionVersion","methodologyVersion","metadataHash"]}}},"required":["from","to","granularity","count","truncated","data"]}
Inputs: to, from, limit, granularity.
Methodology changelog — every registered methodology version with its formula summary, family rule, reference workload, and spec reference, plus activeVersion (the version in force now). Source: Oracle API. Use to interpret SCU values and to pin integrations to a methodology version.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"activeVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"entries":{"type":"array","items":{"type":"object","properties":{"version":{"type":"integer","minimum":0,"exclusiveMinimum":true},"title":{"type":"string"},"meanType":{"type":"string"},"weighting":{"type":"string"},"familyRule":{"type":"object","properties":{"oneFamilyOneSlot":{"type":"boolean"},"familyKeyScheme":{"type":"string"},"representativeSelection":{"type":"string"}},"required":["oneFamilyOneSlot","familyKeyScheme","representativeSelection"]},"referenceWorkload":{"type":"object","properties":{"inputTokens":{"type":"integer","minimum":0,"exclusiveMinimum":true},"outputTokens":{"type":"integer","minimum":0,"exclusiveMinimum":true}},"required":["inputTokens","outputTokens"]},"cacheReasoningInIndex":{"type":"boolean"},"formulaSummary":{"type":"string"},"rationale":{"type":"string"},"specUrl":{"type":"string","nullable":true}},"required":["version","title","meanType","weighting","familyRule","referenceWorkload","cacheReasoningInIndex","formulaSummary","rationale","specUrl"]}}},"required":["activeVersion","entries"]}
Inputs: no named parameters.
Which models can serve a request right now — call it before choosing a model, so a model that cannot serve is ruled out before the request instead of after a 503. Source: Compute Finance API (/v1/models/availability). Carries computedAt (when the exchange computed this answer), ttlSeconds (how long it considers the answer fresh), models — an array of every catalogue model as id, the canonical vendor-prefixed id ('anthropic/claude-opus-4.8', 'openai/gpt-5.5'), plus a routable boolean — and auto, carrying the id the auto alias points at in this snapshot. The signal is advisory: it is true as of computedAt and only for ttlSeconds after it, capacity moves on its own, and a model reported routable can still fail the send — handle the error on the request itself rather than reading this answer as a guarantee. The answer is the exchange's own, served verbatim with no liveness computed here, so it cannot disagree with what the router does. It covers the public pool and takes no arguments. Private offers are not listed: a model a supplier offers to a private pool, under a handle/alias id, is listed only once the pool's owner accepts the offer, and then only to API keys bound to that pool; this server sends no such key — to see them, call GET /v1/models with a ct_live_* key bound to the pool. Says nothing about price: use data_get_catalog or data_get_basket for what the routable models cost and compute_estimate for the cost of the one you settle on.
Inputs: no named parameters.
Per-model input/output USD price effective at a specific timestamp. Source: Oracle API (/v1/oracle/models/{model}/price-at). Response is a discriminated union by source: 'manifest' when the model is the family representative in the revision active at that date (cross-links revisionVersion, methodologyVersion, metadataHash, family for verification), or 'catalog' when only catalog pricing exists (step-function fallback). The model is named by its canonical vendor-prefixed id ('anthropic/claude-opus-4.8'); the bare name ('claude-opus-4.8') names the same model. modelKey echoes the canonical id; manifestKey carries the bare key the attested manifest is keyed by and ships with every 'manifest' response. observedAt reflects when the price was recorded. Returns an error for malformed or future dates, untracked models, or dates preceding all available data.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"modelKey":{"type":"string"},"manifestKey":{"type":"string"},"date":{"type":"string","format":"date-time"},"inputPriceUsdPerMillion":{"type":"number"},"outputPriceUsdPerMillion":{"type":"number"},"observedAt":{"type":"string","format":"date-time"},"source":{"type":"string","enum":["manifest","catalog"]},"revisionVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"metadataHash":{"type":"string","pattern":"^0x[0-9a-f]{64}$"},"family":{"type":"string","nullable":true}},"required":["modelKey","date","inputPriceUsdPerMillion","outputPriceUsdPerMillion","observedAt","source","family"]}
Inputs: date (required), model (required).
Per-model input/output USD price time series — date-range history for any oracle-tracked model. Source: Oracle API (/v1/oracle/models/{model}/price-history). Each point carries input/output USD per million tokens, a source ('manifest' | 'catalog'), plus revisionVersion, methodologyVersion and metadataHash on attested points. Catchup revisions whose manifest is unavailable are surfaced in unavailableRevisions. Same granularity (per-revision/daily/weekly) and limit semantics as data_get_history. The model is named by its canonical vendor-prefixed id ('anthropic/claude-opus-4.8'); the bare name ('claude-opus-4.8') names the same model. modelKey echoes the canonical id; manifestKey carries the bare key the attested manifest is keyed by and ships whenever at least one point has source 'manifest'. Errors only when the model has neither an attested appearance nor a catalog price.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"from":{"type":"string"},"to":{"type":"string"},"granularity":{"type":"string","enum":["per-revision","daily","weekly"]},"count":{"type":"integer","minimum":0,"exclusiveMinimum":false},"truncated":{"type":"boolean"},"modelKey":{"type":"string"},"manifestKey":{"type":"string"},"family":{"type":"string","nullable":true},"unavailableRevisions":{"type":"array","items":{"type":"integer","minimum":0,"exclusiveMinimum":true}},"data":{"type":"array","items":{"type":"object","properties":{"date":{"type":"string"},"inputPriceUsdPerMillion":{"type":"number"},"outputPriceUsdPerMillion":{"type":"number"},"source":{"type":"string","enum":["manifest","catalog"]},"revisionVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"metadataHash":{"type":"string","pattern":"^0x[0-9a-f]{64}$"}},"required":["date","inputPriceUsdPerMillion","outputPriceUsdPerMillion","source"]}}},"required":["from","to","granularity","count","truncated","modelKey","family","unavailableRevisions","data"]}
Inputs: model (required), to, from, limit, +1 more.
Price for a single oracle-tracked model — index members and catalog-only entries on identical terms. Returns base_input/base_output USD per million tokens (the provider list price), routing_fee_rate, and billed_* = base × (1 + routing_fee_rate) — what compute.finance charges. Per-component cache pricing (cachedInput, cacheWrite5m, cacheWrite1h) and the reasoning block carrying reasoningOutput (the whole block is null when the model has no reasoning price) are on the base basis. Every price is the live catalogue figure the exchange bills, so two models with the same provider price return the same numbers regardless of index membership. A provenance mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. base_price_provenance carries one mark for base_input and one for base_output, populated for every tracked model. Every cache and reasoning component carries its own mark. context_tiers carries the model's long-context price ladder. A long-context price ladder ascends by from_input_tokens and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on from_input_tokens takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} provenance pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. max_input_tokens is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. context_tiers is null — never a one-rung ladder — when the catalogue cannot be read or does not list the model, so an unknown ladder is never served as a flat price; max_input_tokens is null alongside it. price_source ('oracle-basket' | 'oracle-catalog') names the serving endpoint only and does not change the pricing basis. Errors with 'Model not tracked by oracle' for unknown keys. Source: Oracle API (/v1/oracle/resolve + /v1/oracle/catalog). Models are identified by their canonical vendor-prefixed id ('anthropic/claude-opus-4.8', 'openai/gpt-5.5'); the bare name ('gpt-5.5') resolves to the same model, and the response echoes the canonical id. The vendor slug is not always provider.key (alibaba → qwen, xai → x-ai, moonshot → moonshotai), so pass an id the API returned rather than assembling one.
Inputs: model (required).
Historical index changes — each entry carries publishedAt, revisionVersion, methodologyVersion, scuBefore/scuAfter, a summary and the attesting txHash, plus a typed changes[] list (MODEL_ADDED, MODEL_REMOVED, PRICE_CHANGE, WORKLOAD_CHANGE). changes[].modelKey is the bare manifest key ('claude-opus-4.8'), not the canonical vendor-prefixed id — strip the vendor prefix off a catalog modelKey before joining on it. Source: Oracle API. Sorted most recent first. Use the optional limit parameter to cap results.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"entries":{"type":"array","items":{"type":"object","properties":{"id":{"type":"string"},"revisionVersion":{"type":"integer"},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"previousVersion":{"type":"integer","nullable":true},"publishedAt":{"type":"string"},"summary":{"type":"string"},"scuBefore":{"type":"number","nullable":true},"scuAfter":{"type":"number"},"changes":{"type":"array","items":{"type":"object","properties":{"type":{"type":"string"},"modelKey":{"type":"string"},"description":{"type":"string"},"before":{"type":"object","additionalProperties":{}},"after":{"type":"object","additionalProperties":{}}},"required":["type","description"]}},"txHash":{"type":"string","nullable":true}},"required":["id","revisionVersion","methodologyVersion","previousVersion","publishedAt","summary","scuBefore","scuAfter","changes","txHash"]}}},"required":["entries"]}
Inputs: limit.
Current Standard Compute Unit (SCU) — value plus the methodology-versioned breakdown discriminated union listing every family representative with USD-per-million-token prices and blended cost. Also carries computeIndex: the inverse purchasing-power view (baseline / scuUsd) × 100, anchored at 100 at the first confirmed revision. The response carries methodologyVersion; see data_get_methodology for the formula in force. breakdown.familyRepresentatives[].modelKey is the bare manifest key ('claude-opus-4.8'), not the canonical vendor-prefixed id — strip the vendor prefix off a catalog modelKey before joining on it. For the breakdown alone, use data_get_breakdown; for the baseline denominator, use data_get_baseline. Source: Oracle API.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"scuUsd":{"type":"number"},"computeIndex":{"type":"number","nullable":true},"referenceWorkload":{"type":"object","properties":{"inputTokens":{"type":"number"},"outputTokens":{"type":"number"}}},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"breakdown":{"oneOf":[{"type":"object","properties":{"methodologyVersion":{"type":"number","minimum":1,"maximum":1},"familyRepresentatives":{"type":"array","items":{"type":"object","properties":{"family":{"type":"string"},"modelKey":{"type":"string"},"inputPriceUsdPerMillion":{"type":"number"},"outputPriceUsdPerMillion":{"type":"number"},"blendedCostUsd":{"type":"number"}},"required":["family","modelKey","inputPriceUsdPerMillion","outputPriceUsdPerMillion","blendedCostUsd"]}}},"required":["methodologyVersion","familyRepresentatives"]}]},"updatedAt":{"type":"string"}},"required":["scuUsd","computeIndex","referenceWorkload","methodologyVersion","breakdown","updatedAt"]}
Inputs: no named parameters.
SCU value active at a specific timestamp via step function — no interpolation. Source: Oracle API (/v1/oracle/scu-at). Resolves the latest confirmed revision with publishedAt ≤ date and returns its scuUsd, scuUsd18, computeIndex, revisionVersion, methodologyVersion, publishedAt, and metadataHash. Monotonicity is non-strict — when two confirmed revisions share publishedAt the highest revisionVersion wins. computeIndex is derived as (baseline.scuUsd / scuUsd) × 100, the same formula as data_get_scu and each data_get_history point. Returns null when the date precedes the genesis revision; errors on malformed or future dates. Use data_get_history for a bucketed series; use data_get_scu_at for a single-point lookup.
Oracle response schema (auto-derived from OpenAPI at startup): {"type":"object","properties":{"at":{"type":"string","format":"date-time"},"scuUsd":{"type":"number"},"scuUsd18":{"type":"string"},"computeIndex":{"type":"number","nullable":true},"revisionVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"methodologyVersion":{"type":"integer","minimum":0,"exclusiveMinimum":true},"publishedAt":{"type":"string","format":"date-time"},"metadataHash":{"type":"string","pattern":"^0x[0-9a-f]{64}$"}},"required":["at","scuUsd","scuUsd18","computeIndex","revisionVersion","methodologyVersion","publishedAt","metadataHash"]}
Inputs: date (required).
Pre-formatted table of recent Claude Code sessions across all projects — per-session Prompts · Inferences · Tool calls, tokens, and effective/nominal cost. Source: local Claude Code transcripts + Oracle API. Print the text field verbatim. Defaults to last 24h, top 10.
Inputs: cwd, hours, limit.
Pre-formatted per-inference breakdown for cf-session-consumption skill. Source: local Claude Code transcript + Oracle API. Bar chart, tool aggregates, mechanical facts; one row per assistant reply (Innn). Header carries the canonical Prompts · Inferences · Tool calls triplet — same numbers as render_session_report and render_active_sessions. Print the text field verbatim. Pass full=true to show every inference instead of top-10/last-5.
Inputs: cwd, full, session_id.
Pre-formatted session cost report for cf-session-management skill. Source: local Claude Code transcript + Oracle API. Reads the transcript, prices it, logs to history, returns a text string. Header carries the canonical Prompts · Inferences · Tool calls triplet (user prompts, assistant replies, tool_use blocks — three distinct counters). Print verbatim — do not reformat or interpret. Omit session_id for the most recent session.
Inputs: cwd, session_id.
Aggregate stats across logged sessions (deduped, last-wins). Source: local ~/.compute-finance/ storage. Sample size, cumulative effective vs nominal cost, per-profile medians, insights (cache dominance). Insights require at least 5 sessions.
Inputs: no named parameters.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 22 tools
The set has several near-neighbour clusters — data_get_catalog vs data_get_basket vs data_get_price, data_get_scu vs data_get_breakdown vs data_get_cpi vs data_get_scu_at, and analyze_session vs analyze_inferences vs the two render_* tools. However, each description explicitly states its boundary and points to the sibling tool for the adjacent case ('For a single model, use data_get_price instead'), so an agent can tell them apart. The only residual ambiguity is the JSON-vs-preformatted pairing, which is subtle but documented.
Names are uniformly snake_case verb_noun with a domain namespace prefix (data_get_*, compute_*, analyze_*, render_*), and within each namespace the pattern is predictable. The single outlier is telemetry_get_history, which injects the noun before the verb instead of using telemetry_get_* or a data_ prefix. Overall readable and grouped by concern.
22 tools is on the heavy side of the 16-25 band for what is a read-only oracle/pricing surface. Most are justified by genuinely distinct query shapes (current vs historical vs at-timestamp vs baseline vs breakdown), but the four session/telemetry analysis tools and the parallel JSON/render pairs inflate the set. A thinner surface could serve the same workflows.
Coverage is broad: catalog, live prices, SCU current/at-time/history, per-model price history and at-time, baseline, CPI, breakdown, methodology, reconstitutions, availability, cost estimation, comparison, and session telemetry all have dedicated tools. Gaps are minor — e.g. no batch per-model price query and no cross-model historical price comparison — and can be worked around by looping the single-model tools. The absence of write operations matches the read-only domain.
Live LLM API pricing: token prices, comparisons, cheapest-model lookups. No key required.
Look up, compare and track AI model API prices from an AI assistant. No sign-in needed.
Find AI model pricing, estimate token costs and compare offers. No API key required.
Real-time, drift-verified LLM pricing across 31 providers with cost+quality model routing.
