Documentation.

What is the CPI?

The Compute Price Index ("CPI") is a public benchmark that tracks the cost of AI inference across major providers. It produces a single equal-weighted reference price — the Standard Compute Unit ("SCU") — calculated from a basket of 22 models across 9 providers.

The Problem

LLM inference pricing is fragmented. Every provider quotes pricing differently — per token, per character, per request, per model. There is no standardized way to benchmark or compare the cost of AI computation across models and providers. You need a verifiable pricing reference you can audit independently.

The Solution

The CPI is an equal-weighted basket of 22 AI models across 9 providers that produces a single, verifiable unit of account: the Standard Compute Unit (SCU). The SCU represents the USD cost of a reference workload, 1,000 input tokens + 500 output tokens, taken as the geometric mean across the full basket.

Key Properties

• Diversified — 22 models across 9 providers prevent any single provider from dominating the index.
• Outlier-resistant — The geometric mean dampens any single model's impact, and the one-family-one-slot rule prevents version pile-up. No caps needed; the math does the work.
• Versioned — The equal-weighted basket launches as v1.0 on June 18, 2026. Reconstitution-driven, published on-chain when basket composition or provider rate-card prices change. There is no fixed cadence.

Basket Composition

The CPI tracks 22 models from 9 providers. Every model family gets one slot, the latest version always, and each model is weighted equally. A family is a provider's distinct product line (e.g. openai.gpt, anthropic.claude); the latest released model in each family is its representative. On a new release the representative auto-rolls. The basket updates with a new version number when families are added, removed, or replaced.

SCU Formula

The Standard Compute Unit is calculated in two steps. The reference workload is fixed at 1000 input + 500 output tokens, evaluated across all basket models.

The SCU is reconstitution-driven. It is published on-chain whenever the basket changes, either because a model is added, removed, or replaced, or because a provider updates a rate-card price. Both triggers produce a new on-chain version. There is no fixed cadence and no continuous off-chain feed.

Governance

The model-family rule reduces governance to a minimum. One eligibility rule, one family rule, one emergency trigger. No weight committees, no tier reviews.

On-Chain Verification

All CPI pricing is recorded on-chain via the OracleRegistry contract on Base. You can independently verify prices without trusting the Compute Finance API.

import { ethers } from "ethers";

const ORACLE_REGISTRY = "0x1b91c0961928a14a2eD6c1985bC11aF1b302714D";
const ABI = [
  "function lastRevisionVersion() view returns (uint256)",
  "function getLatestRevision() view returns (tuple(uint256 revisionVersion, uint16 methodologyVersion, uint256 scuUsd, bytes32 contentHash, bytes32 metadataHash, uint64 publishedAt))",
  "function getBaseline() view returns (uint256)",
  "function getComputeIndex() view returns (uint256)"
];

const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");
const oracle = new ethers.Contract(ORACLE_REGISTRY, ABI, provider);

// Read latest revision header
const latest = await oracle.getLatestRevision();
console.log("revisionVersion:", latest.revisionVersion.toString());
console.log("SCU (USD, 18-dec):", ethers.formatUnits(latest.scuUsd, 18));
console.log("metadataHash:", latest.metadataHash);

// Inverse purchasing-power index — (baseline / SCU) × 100
const computeIndex = await oracle.getComputeIndex();
console.log("Compute Index:", ethers.formatUnits(computeIndex, 18));

// Per-model prices live in the off-chain manifest fetched by metadataHash —
// resolve at /v1/oracle/manifest/{metadataHash} and verify with JCS+keccak256.

Public API

All oracle endpoints are public and require no authentication. Read access is free and unrestricted. Base URL: https://api.compute.finance

Endpoints

Code Examples

All endpoints are public. No authentication required.

curl https://api.compute.finance/v1/oracle/scu

curl https://api.compute.finance/v1/oracle/models

curl https://api.compute.finance/v1/oracle/models/claude-opus-5

curl "https://api.compute.finance/v1/oracle/history?from=2026-05-18T00:00:00Z&to=2026-06-18T00:00:00Z&granularity=daily"

Response Schemas

{
  "scuUsd": 0.002435,
  "computeIndex": 100.00,
  "referenceWorkload": { "inputTokens": 1000, "outputTokens": 500 },
  "methodologyVersion": 1,
  "breakdown": {
    "methodologyVersion": 1,
    "familyRepresentatives": [
      {
        "family": "openai.gpt",
        "modelKey": "gpt-5.5",
        "inputPriceUsdPerMillion": 5.0,
        "outputPriceUsdPerMillion": 30.0,
        "blendedCostUsd": 0.02
      }
    ]
  },
  "updatedAt": "2026-06-18T12:00:00Z"
}

{
  "models": [
    {
      "id": "gpt-5.5",
      "displayName": "GPT-5.5",
      "provider": { "key": "openai", "name": "OpenAI" },
      "family": "openai.gpt",
      "integrated": true,
      "usdPricePerMillion": { "input": 5.0, "output": 30.0 },
      "weiPricePerMillion": { "input": "756430000000000000000", "output": "4538580000000000000000" },
      "markedUpUsdPricePerMillion": { "input": 5.25, "output": 31.5 },
      "markedUpWeiPricePerMillion": { "input": "794252000000000000000", "output": "4765509000000000000000" },
      "releasedAt": "2026-04-01T00:00:00Z",
      "cache": null,
      "reasoning": null
    }
  ]
}

Error catalog

Every API response uses the envelope below on failure. Branch on error.code rather than HTTP status or error.message text — the code taxonomy is stable, message copy may change.

{
  "error": {
    "message": "The Bearer API key is missing, malformed, or not recognized.",
    "type": "invalid_request_error",
    "code": "invalid_api_key",
    "param": "authorization",                    // optional, set when the error binds to a field
    "details": { ... },                          // optional, code-specific structured payload
    "issues": [ ... ]                            // present when one or more fields fail validation
  }
}

Inference API

An OpenAI- and Anthropic-compatible inference API. Point an official openai or @anthropic-ai/sdk client at Compute Finance by swapping the base URL and providing a ct_live_* key. Requests are billed from your $COMPUTE balance.

Base URL: https://api.compute.finance. Swagger UI: /v1/docs/inference · Get a key: https://compute.finance/dashboard/api-keys.

Authentication

Every endpoint accepts Authorization: Bearer ct_live_*. POST /v1/messages also accepts x-api-key: ct_live_* for @anthropic-ai/sdk compatibility.

Every request checks the key's state. A key marked active proceeds normally; a frozen key returns 403 API_KEY_FROZEN; a revoked key returns 401 API_KEY_REVOKED; anything unknown or malformed returns 401 INVALID_API_KEY. If a key is restricted to a specific set of models and the request references another, the response is 403 MODEL_RESTRICTED.

Endpoints

Wire-format deltas

Requests are validated before dispatch. Unsupported or malformed params return 422 VALIDATION_FAILED with the offending field in the error body — no tokens are billed.

Provider capability gating. Advanced features (tools, structured outputs) only work on providers that support them natively — currently openai and anthropic. A single named model on another provider returns 422 VALIDATION_FAILED; inside a models[] list, such an entry is skipped and the request fails only if no listed entry supports the feature.

Client fallback list. Send models — an ordered list of catalogue ids (1–8); model, when present, is tried first, then each entry in turn. An entry lacking capacity or a requested capability is skipped; the request is billed at the model that answered (the hold covers the costliest listed entry, the excess is released at settlement), and the served model is returned in the body and the X-Model-Used header. Combining a list with model:auto is rejected. Limitations: a prompt exceeding an entry's context window, or a parameter an entry rejects as invalid, aborts the request rather than falling through — fall-through covers capacity and capability, not 422-class input errors.

OpenAI Chat Completions

Supported params: model, messages, stream, response_format, tools, tool_choice, parallel_tool_calls, plus the standard sampling / limit / logprobs family.

Also accepted: models (ordered fallback list, 1–8 entries), conversation_id.

Not supported (422): legacy functions / function_call (use tools / tool_choice), n > 1, multimodal content arrays.

Anthropic Messages

Supported params: model, messages, max_tokens, system, stream, tools, tool_choice, plus stop_sequences, metadata.user_id, and the sampling family (temperature, top_p, top_k).

Content blocks: text, tool_use, tool_result; cache_control is honored. Also accepted: models (ordered fallback list). Extra fields on message objects are rejected with 422.

Streaming

Both endpoints stream Server-Sent Events (Accept: text/event-stream) when stream: true. Wire formats differ (OpenAI vs Anthropic).

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":...,"model":"gpt-5.5","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}
data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":...,"model":"gpt-5.5","choices":[{"index":0,"delta":{"content":"Hello"},"finish_reason":null}]}
...
data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":...,"model":"gpt-5.5","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":10,"completion_tokens":5,"total_tokens":15},"x_credits_used":"1234","x_credits_remaining":"98765","x_ratelimit_requests_remaining":123}
data: [DONE]

event: message_start
data: {"type":"message_start","message":{"id":"msg_...","type":"message","role":"assistant","content":[],"model":"claude-opus-4-1","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":10,"output_tokens":0}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":5}}

event: message_stop
data: {"type":"message_stop"}

Stop reasons are translated between wire formats: OpenAI stop ↔ Anthropic end_turn; length ↔ max_tokens; tool_calls ↔ tool_use.

The streaming final chunk also mirrors x_credits_used, x_credits_remaining, and x_ratelimit_requests_remaining into the body.

Response headers

Errors

Every error response follows the envelope below. Branch on error.code rather than HTTP status — several codes can share the same status.

{
  "error": {
    "message": "The Bearer API key is missing, malformed, or not recognized.",
    "type": "invalid_request_error",
    "code": "invalid_api_key",
    "param": "authorization",                    // optional, set when the error binds to a field
    "details": { ... },                          // optional, code-specific structured payload
    "issues": [ ... ]                            // present when one or more fields fail validation
  }
}

Rate limits

Per-key. Each API key can carry optional daily, weekly, and monthly $COMPUTE caps. Exceeding any cap returns 429 SPENDING_LIMIT_REACHED; the remaining budget is exposed in the X-Key-*-Remaining headers.

Per-pool. Each provider pool has RPM and TPM ceilings. Exceeding either returns 429 RATE_LIMITED.

GET /v1/inference/estimate is throttled to 10 requests per second per source IP; it requires no authentication and does not consume $COMPUTE.

Billing

Cost is estimated up-front, reserved from the balance, then settled against actual token usage. The X-Compute-Used and X-Compute-Remaining headers report the final debit and remaining balance. An insufficient balance returns 402; hitting a per-key or per-account cap returns 429.

Models

GET /v1/models returns the routable catalog in OpenAI format. Use id (or a value from routingAliases) as the model parameter. Setting model: "auto" enables content-based auto-routing. The full catalog with prices is available at https://api.compute.finance/v1/oracle/catalog.

Quickstarts

Snippets use pinned SDK versions. Replace ct_live_... with a key issued at https://compute.finance/dashboard/api-keys.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.compute.finance/v1",
    api_key="ct_live_...",
)

resp = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Hello"}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.compute.finance/v1",
  apiKey: process.env.COMPUTE_FINANCE_API_KEY!, // ct_live_...
});

const resp = await client.chat.completions.create({
  model: "gpt-5.5",
  messages: [{ role: "user", content: "Hello" }],
});
console.log(resp.choices[0].message.content);

from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.compute.finance",
    api_key="ct_live_...",
)

resp = client.messages.create(
    model="claude-opus-4-1",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
print(resp.content[0].text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://api.compute.finance",
  apiKey: process.env.COMPUTE_FINANCE_API_KEY!, // ct_live_...
});

const resp = await client.messages.create({
  model: "claude-opus-4-1",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello" }],
});
console.log(resp.content[0].text);

curl https://api.compute.finance/v1/chat/completions \
  -H "Authorization: Bearer ct_live_..." \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-5.5","messages":[{"role":"user","content":"Hello"}]}'

Machine-readable specifications

OpenAPI YAML · OpenAPI JSON · llms-full.txt

Model Context Protocol (MCP)

AI agents can query the oracle, estimate costs, and analyze sessions through the official Compute Finance MCP server. Stdio transport, no API key required.

Install in any MCP client: npx @compute-finance/mcp

Client config snippet: {"command":"npx","args":["@compute-finance/mcp"]}

Claude Code one-liner (registers MCP + skills + cost hook): npx @compute-finance/mcp setup

Read-only tools across five layers:

• data — Live oracle data — basket, price, SCU, CPI, reconstitutions
• compute — Cost estimation and cross-model comparison
• render — Pre-formatted session reports used by the Claude Code skills
• analyze — Raw JSON session and per-inference breakdown
• history — Aggregate stats across logged sessions

Bundled Claude Code slash skills:

• /cf-session-management — Measured post-session cost analysis
• /cf-session-consumption — Per-inference token spend breakdown
• /cf-active-sessions — Multi-session overview across projects

Reference: github.com/compute-finance/mcp · /.well-known/mcp/server-card.json

Compute Finance ID

Your Compute Finance ID (CF ID) is your identity across all Compute Finance surfaces. Created on first sign-in via email or wallet, it ties together your profile, points balance, and referral code into a single record.

What CF ID stores

Sign-in flows

Two sign-in methods, both produce a CF ID:

• Email — Enter your email, receive a 6-digit code, verify. A smart wallet is created on Base and associated with your email. No seed phrase required.
• Wallet — Connect MetaMask, Coinbase Wallet, or any WalletConnect-compatible wallet. Sign a SIWE message. Your wallet address becomes your CF ID's primary identifier.

Both flows converge on the same CF ID record. You can add an email to a wallet-only account later from your settings.

Points

Points track your engagement with Compute Finance — signup, daily logins, oracle interactions, and referrals. As your balance grows, you unlock higher tiers. Points are append-only and recorded in a public ledger per CF ID.

Tiers

How points are earned

V1 supports six earning channels. New channels will be added in future versions and announced via the changelog.

Ledger model

The points ledger is an append-only log. No entries are ever updated or deleted. Your canonical points balance is the sum of all your ledger entries. The denormalized points_balance field on your CF ID record is a performance optimization that is reconciled periodically.

The append-only design means: no points can be silently removed or altered, the complete earning history is preserved and queryable, and any future audit can reconstruct the exact points balance at any point in time.

Streaks

Use Compute Finance on consecutive calendar days to build a streak. Longer streaks earn bonus points. Your current streak and longest streak are shown in your profile. Streaks reset if you miss a calendar day (UTC).

Leaderboard

The top 50 users by total points are displayed on the public leaderboard, refreshed periodically. The leaderboard shows display name and points only — no other profile data is exposed.

Non-transferability

Points are non-transferable in V1. They have no monetary value, are not convertible to any token or currency, and cannot be sold, traded, or assigned to another account. A points-to-credits conversion ratio for V2 will be announced before V2 ships, and the append-only ledger ensures all V1 earning history is preserved and can be converted accurately at that time.

API endpoints

Points data is queryable via the following endpoints. Authentication is required for endpoints that return personal data; the leaderboard is public.

Referral Program

Every CF ID includes a unique referral code (8 characters). Share your link to invite new users — both sides earn points. The program uses first-touch attribution with a 30-day cookie window.

Referral rewards

Sharing your referral link

// Referral URL format
https://compute.finance/r?c=cf_ref_XXXXXXXX

Find your referral code in your Compute Finance ID settings. Share buttons are available for X, LinkedIn, Telegram, and copy-to-clipboard. The link uses a 30-day attribution cookie — referrals count when the referred user creates a CF ID within 30 days of clicking your link.

Attribution model

Referral attribution is first-touch with a 30-day window. The first referral link a user clicks is the one credited if they sign up within the window. Subsequent referral links from other users do not overwrite the original cookie.

How it works step by step:

• A user visits https://compute.finance/r?c=cf_ref_XXXXXXXX
• The server redirects to https://compute.finance and sets a cookie: cf_ref=cf_ref_XXXXXXXX with Max-Age=2592000 (30 days), SameSite=Lax, Secure
• The click is recorded in the database with the referral code, timestamp, hashed IP address, and user agent
• If the user signs up within 30 days — even if they navigate directly to https://compute.finance without the referral link — the cookie is read during CF ID creation and the referral relationship is stored
• If the user has already clicked a different referral link, the first-touch cookie is preserved

Anti-gaming rules

The referral program enforces several rules to prevent farming and abuse. None of these rules surface error messages — invalid referrals are silently ignored to avoid leaking information about user accounts.

Referral dashboard

Your CF ID profile includes a referral dashboard showing:

• Total referral link clicks (all-time)
• Total signups from your referral link
• Conversion rate (signups ÷ clicks)
• Total points earned from referrals
• List of referred users (display name or truncated email, signup date, status: pending or confirmed)

Status transitions

A referral has two possible states. Points are awarded when the status transitions from pending to confirmed:

• pending — The user clicked the referral link but has not yet completed signup
• confirmed — The user has created a CF ID. Points are awarded to both sides within 60 seconds of confirmation.