DeepSeek V3.1 API pricing across inference providers

DeepSeek V3.1 API pricing providers diverge more than you’d expect once you look past the headline token rates. This head-to-head puts the official DeepSeek endpoint, OpenRouter, Together AI, Fireworks, and an OpenAI-compatible gateway in the same matrix so you can choose based on real engineering constraints—not just the cheapest input token.

Providers in the Matrix

We compare five ways to call the same weights:

• DeepSeek Official: The host’s own API, OpenAI-compatible, source of truth for rate cards.
• OpenRouter: Aggregator reselling DeepSeek alongside 200+ models with a unified key.
• Together AI: Inference platform with dedicated GPU clusters and batch APIs.
• Fireworks: Optimized low-latency serving, often with quantized variants.
• n4n.ai: A gateway that exposes one OpenAI-compatible endpoint across 240+ models and falls back automatically when a backend is degraded.

Each exposes deepseek-v3.1 through /v1/chat/completions, but the billing, limits, and failure modes differ.

Capabilities

All five serve the base chat completion surface: streaming, JSON mode, and function calling. DeepSeek Official and Fireworks typically ship new model features (e.g., extended context or native tool parsing) within days of release. OpenRouter and Together mirror the official capability set but may lag on bleeding-edge flags like response_format extensions.

Context window is 128K on official and most resellers; Fireworks sometimes advertises a shorter default but allows raising it via header. If you need prompt caching, only Official and a few gateways honor the cache_control breakpoint convention consistently.

from openai import OpenAI

client = OpenAI(base_url="https://api.deepseek.com/v1", api_key="sk-...")
client.chat.completions.create(
    model="deepseek-v3.1",
    messages=[
        {"role": "system", "content": "You are concise."},
        {"role": "user", "content": "Summarize RFC 9110."}
    ],
    extra_headers={"cache_control": "ephemeral"}  # honored by some providers
)

Price and Cost Model

DeepSeek V3.1 API pricing providers split into two camps: direct metered and resale markup. Official DeepSeek meters per token with a cache-hit tier that cuts input cost roughly 75% when you reuse prefix tokens. OpenRouter applies a percentage margin on top of the official card but keeps the same token accounting. Together and Fireworks quote their own per-token rates, often bundling throughput guarantees; Fireworks may offer a cheaper quantized build at lower accuracy.

Gateways pass through the underlying provider cost and add per-token metering with no minimum, so you see the same line items. None of these charge for failed requests, but only Official and some gateways expose cached-token counts in the usage object by default.

When comparing DeepSeek V3.1 API pricing providers, read the usage JSON, not the marketing table:

{
  "usage": {
    "prompt_tokens": 1200,
    "completion_tokens": 300,
    "cache_read_tokens": 900,
    "total_tokens": 1500
  }
}

Latency and Throughput

Official DeepSeek runs shared clusters; expect p50 around 400–800 ms for a short completion, but p99 degrades under global peak load. Fireworks targets p50 under 200 ms by using speculative decoding and tighter batching. Together gives you reserved capacity slots if you pay for dedicated instances, eliminating noisy-neighbor spikes.

A gateway that implements automatic fallback masks provider degradation by rerouting to a secondary backend when the primary returns 429/503. That trades a small cold-start penalty for drastically lower tail latency in production.

Ergonomics

All endpoints are OpenAI-compatible, so the same openai SDK works. Differences surface in headers and error shapes. Official uses x-request-id and detailed 422s. OpenRouter returns a provider field in the response metadata. Together requires Authorization: Bearer plus an optional Together-Client tag for routing.

Cache control is the sharpest ergonomic divide. DeepSeek Official forwards cache_control breakpoints to the backend; OpenRouter documents it but only applies it on selected models. Fireworks uses its own fw_cache query param.

curl https://api.fireworks.ai/v1/chat/completions \
  -H "Authorization: Bearer $FW_KEY" \
  -d '{"model":"deepseek-v3.1","messages":[...],"fw_cache":true}'

Ecosystem and Limits

Official DeepSeek locks you to one vendor but gives highest rate limits (tens of thousands of req/min at upper tiers). OpenRouter lets you swap to Llama or Claude with one line change, ideal for eval harnesses. Together and Fireworks bundle fine-tuning and batch submission APIs.

Rate limits are the silent cost. DeepSeek V3.1 API pricing providers enforce RPM/TPM tiers; exceeding them throws 429 with retry-after. Gateways aggregate limits across backends, so a 429 from one provider doesn’t kill the request if a fallback exists.

Comparison Table

Which to Choose

Cost-optimized batch jobs: Use DeepSeek Official with aggressive prefix caching. The cache-hit tier and direct rates beat any reseller when you control the prompt layout.

Latency-sensitive production: Fireworks or a gateway with fallback. If you can tolerate slight quantization, Fireworks wins on p50. If you need redundancy, route through a gateway that honors cache_control and reroutes on 503.

Multi-model experimentation: OpenRouter or a similar gateway. You keep one SDK and compare DeepSeek V3.1 against other models without rewriting auth.

High-throughput reserved capacity: Together AI dedicated instances. Pay for GPUs, get predictable TPM and no noisy neighbors.

DeepSeek V3.1 API pricing providers are not interchangeable despite sharing the model name. Match the metering model and failure behavior to your traffic shape before you ship.