How to calculate the cost of a Claude Opus 4.8 API call

Calculating the cost of a Claude Opus 4.8 API call starts with understanding Anthropic’s token-based pricing model, then measuring the actual tokens your requests consume. The formula is straightforward: multiply input tokens by the input rate, output tokens by the output rate, and add any applicable discounts for prompt caching or batch processing. Below is a complete, runnable workflow you can follow end to end.

Step 1: Get the current pricing from Anthropic

Anthropic publishes per-model pricing on their pricing page. For Claude Opus 4.8, you need two numbers:

Input token price (per 1 million tokens)
Output token price (per 1 million tokens)

Prices change occasionally. Always fetch the latest figures programmatically or check the page before you bake numbers into a budget model.

# pricing_fetcher.py
import requests
import re

def fetch_opus_pricing() -> dict:
    """
    Scrape Anthropic's pricing page for Opus rates.
    Returns prices in USD per 1M tokens.
    """
    url = "https://www.anthropic.com/pricing"
    resp = requests.get(url, timeout=10)
    resp.raise_for_status()
    html = resp.text

    # The page structure may change; this regex targets the Opus row.
    # Adjust selectors if the markup shifts.
    pattern = r'Claude Opus 4\.8.*?(\$[\d.]+).*?(\$[\d.]+)'
    match = re.search(pattern, html, re.DOTALL | re.IGNORECASE)
    if not match:
        raise ValueError("Could not parse Opus pricing from page")

    input_price = float(match.group(1).replace("$", ""))
    output_price = float(match.group(2).replace("$", ""))
    return {
        "input_per_1m": input_price,
        "output_per_1m": output_price,
        "source": url,
    }

if __name__ == "__main__":
    print(fetch_opus_pricing())

Run it once, store the result, and refresh weekly via a cron job.

Step 2: Count input tokens before you send the request

Anthropic counts tokens using their tokenizer, which differs slightly from OpenAI’s tiktoken. Use the official anthropic Python SDK — it exposes a count_tokens utility that matches the API’s counting logic exactly.

# token_counter.py
from anthropic import Anthropic
from anthropic.types import MessageParam

client = Anthropic()  # requires ANTHROPIC_API_KEY in env

def count_input_tokens(
    messages: list[MessageParam],
    system: str | None = None,
    tools: list[dict] | None = None,
) -> int:
    """
    Returns the exact input token count the API will bill for.
    """
    return client.messages.count_tokens(
        model="claude-opus-4-8-20250514",  # adjust to the exact model string
        messages=messages,
        system=system,
        tools=tools,
    ).input_tokens

# Example usage
if __name__ == "__main__":
    msgs: list[MessageParam] = [
        {"role": "user", "content": "Summarize the attached PDF in three bullet points."}
    ]
    system_prompt = "You are a concise technical summarizer."
    print(f"Input tokens: {count_input_tokens(msgs, system=system_prompt)}")

Note: If you pass images, PDFs, or tool definitions, include them in the count_tokens call — they consume input tokens too.

Step 3: Estimate or measure output tokens

Output tokens are harder to predict because they depend on the model’s completion. Two practical approaches:

Static ceiling — set a max_tokens limit in your request and budget for the worst case.
Empirical average — log actual usage.output_tokens from production responses over a few thousand calls, then use the 95th percentile for planning.

# output_estimator.py
from dataclasses import dataclass
from anthropic import Anthropic
from anthropic.types import MessageParam

client = Anthropic()

@dataclass
class OutputEstimate:
    max_tokens: int
    p95_observed: int
    recommended_budget: int

def estimate_output_tokens(
    messages: list[MessageParam],
    system: str | None = None,
    max_tokens: int = 4096,
    sample_size: int = 5,
) -> OutputEstimate:
    """
    Runs a few real completions to measure actual output length.
    Use sparingly — each call costs money.
    """
    observed = []
    for _ in range(sample_size):
        resp = client.messages.create(
            model="claude-opus-4-8-20250514",
            messages=messages,
            system=system,
            max_tokens=max_tokens,
            temperature=0.0,  # deterministic for measurement
        )
        observed.append(resp.usage.output_tokens)

    p95 = sorted(observed)[int(0.95 * len(observed))]
    return OutputEstimate(
        max_tokens=max_tokens,
        p95_observed=p95,
        recommended_budget=min(max_tokens, p95 + 200),  # small buffer
    )

if __name__ == "__main__":
    msgs: list[MessageParam] = [
        {"role": "user", "content": "Write a 200-word changelog entry for v2.3.0."}
    ]
    est = estimate_output_tokens(msgs, max_tokens=1024)
    print(f"Max: {est.max_tokens}, P95 observed: {est.p95_observed}, Budget: {est.recommended_budget}")

Run this offline during development, not on every request.

Step 4: Apply the core pricing formula

With input tokens, output tokens, and current prices in hand, the calculation is elementary arithmetic. Keep it in a pure function so you can unit-test it.

# cost_calculator.py
from dataclasses import dataclass

@dataclass(frozen=True)
class Pricing:
    input_per_1m: float   # USD
    output_per_1m: float  # USD

@dataclass(frozen=True)
class Usage:
    input_tokens: int
    output_tokens: int
    cache_read_tokens: int = 0
    cache_write_tokens: int = 0

def calculate_claude_opus_4_8_api_cost(
    usage: Usage,
    pricing: Pricing,
    cache_read_discount: float = 0.10,   # 90% off for cache reads
    cache_write_premium: float = 1.25,   # 25% premium for cache writes
) -> float:
    """
    Returns total cost in USD for a single API call.
    """
    input_cost = (usage.input_tokens / 1_000_000) * pricing.input_per_1m
    output_cost = (usage.output_tokens / 1_000_000) * pricing.output_per_1m

    cache_read_cost = 0.0
    if usage.cache_read_tokens:
        discounted_rate = pricing.input_per_1m * cache_read_discount
        cache_read_cost = (usage.cache_read_tokens / 1_000_000) * discounted_rate

    cache_write_cost = 0.0
    if usage.cache_write_tokens:
        premium_rate = pricing.input_per_1m * cache_write_premium
        cache_write_cost = (usage.cache_write_tokens / 1_000_000) * premium_rate

    return round(input_cost + output_cost + cache_read_cost + cache_write_cost, 6)

# Unit test
if __name__ == "__main__":
    pricing = Pricing(input_per_1m=15.00, output_per_1m=75.00)  # illustrative
    usage = Usage(input_tokens=12_000, output_tokens=2_500)
    cost = calculate_claude_opus_4_8_api_cost(usage, pricing)
    print(f"Estimated cost: ${cost:.6f}")  # ~$0.367500

Step 5: Factor in prompt caching and batch discounts

Anthropic offers two discount mechanisms that materially change the bill:

Mechanism	Discount	When it applies
Prompt cache read	~90% off input rate	Re-using a `cache_control` prefix across requests
Prompt cache write	~25% premium on input rate	First request that writes a new cache entry
Batch API	50% off both rates	Async `/v1/messages/batches` endpoint

Update the Usage dataclass and the calculator to accept these fields — the function above already includes them. When you send a request with cache_control, the response usage object will populate cache_read_input_tokens and cache_creation_input_tokens. Pass those straight into Usage.

# Example: reading a cached system prompt
from anthropic import Anthropic
from anthropic.types import MessageParam

client = Anthropic()

messages: list[MessageParam] = [
    {"role": "user", "content": "What's the capital of France?"}
]

resp = client.messages.create(
    model="claude-opus-4-8-20250514",
    messages=messages,
    system=[
        {
            "type": "text",
            "text": "You are a geography expert. Answer in one sentence.",
            "cache_control": {"type": "ephemeral"}  # enables caching
        }
    ],
    max_tokens=100,
)

usage = Usage(
    input_tokens=resp.usage.input_tokens,
    output_tokens=resp.usage.output_tokens,
    cache_read_tokens=resp.usage.cache_read_input_tokens or 0,
    cache_write_tokens=resp.usage.cache_creation_input_tokens or 0,
)
print(usage)
# First call: cache_write_tokens > 0, cache_read_tokens == 0
# Subsequent calls: cache_read_tokens > 0, cache_write_tokens == 0

Step 6: Build a drop-in cost tracker for your codebase

Wrap the pieces into a context manager or decorator that logs every call’s actual cost to your observability stack (Datadog, Prometheus, CloudWatch, etc.).

# cost_tracker.py
import time
import logging
from contextlib import contextmanager
from typing import Iterator
from anthropic import Anthropic
from anthropic.types import Message, MessageParam, Usage as AnthropicUsage

from cost_calculator import (
    Pricing,
    Usage,
    calculate_claude_opus_4_8_api_cost,
    fetch_opus_pricing,
)

logger = logging.getLogger(__name__)
_pricing_cache: Pricing | None = None

def get_pricing() -> Pricing:
    global _pricing_cache
    if _pricing_cache is None:
        data = fetch_opus_pricing()
        _pricing_cache = Pricing(
            input_per_1m=data["input_per_1m"],
            output_per_1m=data["output_per_1m"],
        )
    return _pricing_cache

@contextmanager
def track_cost(
    model: str,
    messages: list[MessageParam],
    system: str | list[dict] | None = None,
    **create_kwargs,
) -> Iterator[Message]:
    """
    Usage:
        with track_cost(model, messages, system=sys) as resp:
            print(resp.content[0].text)
    Logs actual cost after the call completes.
    """
    client = Anthropic()
    start = time.perf_counter()
    resp = client.messages.create(
        model=model,
        messages=messages,
        system=system,
        **create_kwargs,
    )
    latency_ms = int((time.perf_counter() - start) * 1000)

    pricing = get_pricing()
    usage = Usage(
        input_tokens=resp.usage.input_tokens,
        output_tokens=resp.usage.output_tokens,
        cache_read_tokens=resp.usage.cache_read_input_tokens or 0,
        cache_write_tokens=resp.usage.cache_creation_input_tokens or 0,
    )
    cost_usd = calculate_claude_opus_4_8_api_cost(usage, pricing)

    logger.info(
        "llm_call_complete",
        extra={
            "model": model,
            "input_tokens": usage.input_tokens,
            "output_tokens": usage.output_tokens,
            "cache_read_tokens": usage.cache_read_tokens,
            "cache_write_tokens": usage.cache_write_tokens,
            "cost_usd": cost_usd,
            "latency_ms": latency_ms,
        },
    )
    yield resp

Drop this into any service and you get per-request cost visibility without changing business logic.

Step 7: Verify the calculation against real invoices

The only ground truth is Anthropic’s monthly invoice. Reconcile weekly:

Export usage logs from your observability backend (sum of cost_usd per day).
Download the CSV from Anthropic’s console (Settings → Billing → Export).
Compare totals. They should match within rounding error (±$0.01–$0.02 per 1k calls).

-- Example: daily reconciliation query (PostgreSQL)
WITH logged AS (
    SELECT
        date_trunc('day', timestamp) AS day,
        SUM(cost_usd) AS logged_total
    FROM llm_call_logs
    WHERE model = 'claude-opus-4-8-20250514'
    GROUP BY 1
),
billed AS (
    SELECT
        date_trunc('day', timestamp) AS day,
        SUM(amount_usd) AS billed_total
    FROM anthropic_invoice_lines
    WHERE model = 'claude-opus-4-8-20250514'
    GROUP BY 1
)
SELECT
    l.day,
    l.logged_total,
    b.billed_total,
    (l.logged_total - b.billed_total) AS delta
FROM logged l
JOIN billed b USING (day)
WHERE ABS(l.logged_total - b.billed_total) > 0.05
ORDER BY l.day DESC;

Investigate any row where delta exceeds a few cents. Common culprits:

Uncounted cache writes — first request of a new cache prefix bills at the premium rate.
Batch vs. online pricing — ensure your Pricing object matches the endpoint you hit.
Token counting drift — Anthropic occasionally updates their tokenizer; re-run count_tokens on your canonical prompts after each model version bump.

How to verify success

You have successfully implemented cost calculation when:

Unit tests pass — calculate_claude_opus_4_8_api_cost returns the expected dollar amount for fixed inputs.
Integration logs match — the cost_usd logged by track_cost equals the manual calculation using the response’s usage object and the same Pricing struct.
Monthly reconciliation shows < $0.10 variance per 10,000 calls after accounting for known cache-write premiums.
Budget alerts fire — you can set a daily spend ceiling (e.g., $500/day) and trigger a page when the rolling 24-hour sum of logged cost_usd exceeds it.

Once those four checks are green, you can trust the numbers for forecasting, per-feature attribution, and automated cost-control guardrails.