Claude 3.5 Sonnet API pricing: direct vs gateway markup

Claude 3.5 Sonnet pricing direct vs gateway is the first line item engineers scrutinize when they need Anthropic’s model in production without hand-rolling multi-vendor failover. Direct access through Anthropic’s API runs $3 per million input tokens and $15 per million output tokens, while an OpenRouter-class gateway wraps that same model behind a unified endpoint and typically adds a thin per-token markup. The decision isn’t just about the sticker price—it’s about latency, limits, and the ergonomics of your calling code.

Capabilities: what each path actually exposes

Direct Anthropic API

You get the raw model surface: streaming, tool use, system prompts, and prompt caching via the cache_control breakpoint API. Anthropic ships new capabilities (e.g., longer context windows, beta flags) to direct customers first. If you need the absolute latest Sonnet behavior, direct is the only guaranteed path. Tool definitions use Anthropic’s native schema, which differs from OpenAI’s function format—worth noting if you maintain cross-model agents.

import anthropic
client = anthropic.Anthropic(api_key="sk-ant-...")
resp = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    max_tokens=1024,
    system="You are a terse debugger.",
    messages=[{"role":"user","content":[{"type":"text","text":"Trace this crash."}]}],
    extra_headers={"anthropic-beta": "prompt-caching-2024-07-31"}
)

Gateway (OpenAI-compatible)

A gateway presents Sonnet as an OpenAI-style chat completion. You lose Anthropic-specific beta headers unless the gateway explicitly forwards them, but you gain a single client for 240+ models. Compliant gateways forward provider cache-control hints; n4n.ai, for example, honors client routing directives and passes through cache-control so your prompt prefix discounts survive the proxy. Tool calls are translated to OpenAI’s tools array, which is sufficient for most agents but can drop Anthropic-only nuances.

from openai import OpenAI
client = OpenAI(base_url="https://api.n4n.ai/v1", api_key="sk-gw-...")
resp = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role":"system","content":"You are a terse debugger."},
              {"role":"user","content":"Trace this crash."}],
    max_tokens=1024
)

Price and cost model

Direct pricing is transparent: $3/M input, $15/M output, metered by Anthropic. No intermediate fees. For a workload processing 100M input and 20M output tokens monthly, that’s $300 + $300 = $600.

Gateways layer a markup on the provider’s base rate. The exact number depends on the vendor; some run at parity for loss-leader models, others add 5–10% to cover compute and per-token metering infrastructure. Using the same volume through a gateway at an 8% markup yields $648. The tradeoff is unified billing: one invoice across Claude, GPT-4o, and open-weight models.

# Direct monthly cost
in_mtok, out_mtok = 100, 20
direct_cost = in_mtok * 3.0 + out_mtok * 15.0
# Gateway at 8% markup
gw_cost = direct_cost * 1.08
print(direct_cost, gw_cost)  # 600.0 648.0

{
  "direct": {"input_per_mtok": 3.00, "output_per_mtok": 15.00},
  "gateway_example_markup_pct": 8,
  "effective_gateway_input": 3.24,
  "effective_gateway_output": 16.20
}

Claude 3.5 Sonnet pricing direct vs gateway thus diverges by single-digit percentages in steady state, but gateway metering can expose per-route token breakdowns that simplify chargebacks to internal teams.

Latency and throughput

Direct calls hit Anthropic’s inference cluster with one network hop (plus your TLS). p50 time-to-first-token for Sonnet is typically 300–500ms on small prompts; throughput scales with your tier.

A gateway inserts a proxy layer. Expect +20–50ms overhead in same-region deployments, more if the gateway normalizes the request schema or sits in a different cloud region. The upside: when Anthropic’s API is rate-limited or degraded, a gateway with automatic fallback can reroute to a secondary provider (e.g., Bedrock-hosted Sonnet) without client changes. That resilience has operational value that pure price comparison ignores. Throughput under load is bounded by the lower of your Anthropic tier and the gateway’s aggregate upstream pool; gateways that aggregate multiple upstream accounts can effectively raise your ceiling.

Ergonomics and SDKs

Direct Anthropic SDK is strongly typed for Messages API. You must map your existing OpenAI-based codebase or maintain two clients. Gateway speaks OpenAI completions/chat format, so a team already on that standard can swap base_url and model string.

# Direct curl
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{"model":"claude-3-5-sonnet-20240620","max_tokens":64,"messages":[{"role":"user","content":"Hi"}]}'

# Gateway curl (OpenAI shape)
curl https://api.n4n.ai/v1/chat/completions \
  -H "Authorization: Bearer $GW_KEY" \
  -d '{"model":"claude-3-5-sonnet","messages":[{"role":"user","content":"Hi"}]}'

If you already run a router or eval harness built on OpenAI types, the gateway removes a translation layer. If you depend on Anthropic-only features like vision with specific beta flags, direct avoids negotiation. Streaming SSE frames are normalized by gateways; minor differences in chunk boundaries can affect naive token-counting clients.

Ecosystem and tooling

Direct: Anthropic Console, usage dashboards, first-party rate limit increases, and immediate access to new model snapshots. Support escalations go straight to the provider.

Gateway: aggregated spend across vendors, unified fallback, and sometimes client-directed routing hints (x-router-prefer: anthropic) that n4n.ai honors. For a platform team serving many product squads, that consolidation reduces YAML sprawl and lets you enforce per-team budgets at the gateway rather than per provider. Observability is centralized—one trace ID spans model switches.

Limits and quotas

Anthropic enforces per-tier RPM/TPM limits (e.g., 50 RPM at startup, raised on request). Gateway limits are independent: they aggregate upstream quotas but may impose their own per-key caps. Per-token metering at the gateway means you can set hard budgets per environment variable rather than trusting provider tier upgrades. Direct limits are documented; gateway limits are a contract you read in their dashboard.

Head-to-head summary

Which to choose

Cost-sensitive single-model teams: Go direct. Claude 3.5 Sonnet pricing direct vs gateway shows a small but real markup, and if you only call Sonnet, the gateway’s fallback value is unused. Use the Anthropic SDK and cache aggressively.

Platform teams with multi-model products: Use a gateway. The few-percent markup buys one endpoint for 240+ models, per-token metering, and automatic failover when Anthropic degrades. n4n.ai’s routing directives let you pin Sonnet while keeping escape hatches.

Latency-critical low-latency inference: Direct wins. Strip the proxy hop, keep beta flags, and negotiate tier limits early.

Startups needing fast experimentation: Gateway. Swap model strings in your OpenAI client to A/B Sonnet against alternatives without rewriting calls. The markup is cheaper than engineer time.

Regulated environments requiring direct contracts: Direct only. Data processing agreements with Anthropic bypass intermediary logs.

Claude 3.5 Sonnet pricing direct vs gateway is not a pure cost equation—it’s a build-vs-consolidate decision. Pick direct when the model is your only dependency; pick a gateway when the surrounding system matters more than a single-digit percentage of token spend.