DeepSeek V4 Pro API: EU hosting, pricing and context limits. One very long purple-topped slab and one small outlined block after it, suggesting a very long prompt that is reused before a short new turn.

For an agent that resends the same code every turn, the cache decides the bill more than the list price. A repeated prompt start costs a quarter of the normal input rate. Keeping that start stable cuts each turn by more than half in our example.

Where can you run DeepSeek's largest open model with processing in Europe, and what will it cost per agent session? The answer decides your data path and your monthly bill, so it is worth working through with real numbers.

Where the DeepSeek V4 Pro API runs and what we keep

Lyceum is a sovereign European AI inference provider for open-source models, as our press page puts it: built and run in Europe. Serverless means you call the API and we run the GPUs. Our serverless models run in Paris and Finland. Both DeepSeek V4 Pro model pages list the processing region as EU-hosted.

Our trust page follows a request through each stop and lists what we keep there.

Calling it through an API also saves you hardware, because DeepSeek V4 Pro is a large model to run yourself. It has 1.6 trillion parameters, of which 49 billion are active for each token. It is a mixture of experts (MoE): each token passes through only a few of its sub-networks. DeepSeek's own example for vLLM, an open-source serving engine, runs the 0813 release on one server with four NVIDIA GB300 GPUs. Our API removes that hardware step.

Open models are also close enough to the frontier to make this a real choice. Open-weight models are models whose weights are published for anyone to run. Epoch AI found that since January 2026, the most capable open-weight models have trailed the best closed models by about four months on average.

DeepSeek V4 Pro API pricing and model ID

We bill DeepSeek V4 Pro per token, in US dollars, with no base fee. The prices below come from our models page, read on 21 October 2026.

Model IDContext windowInputCached inputOutput
deepseek/deepseek-v4-pro-08131M tokens$2.00$0.50$4.00
deepseek/deepseek-v4-flash-0731 (for comparison)1M tokens$0.25$0.06$0.30

Prices are per 1M tokens.

The 0813 ID is DeepSeek's general-availability release of 13 August 2026. DeepSeek describes it as the official release that replaces the Preview, the earlier test version of V4 Pro. Its model page and our docs list its full limits and behaviour. Our API also accepts deepseek/deepseek-v4-pro as another name for it. In our test calls on 21 October 2026, requests to that name ran and were billed as 0813.

We also measure speed. Our status checks measured a median time to first token of 260 ms over the 7 days to 21 October 2026. Time to first token is the wait before the answer starts. Output ran at a median of 73 tokens per second. Both medians are for short requests. Reasoning tokens count towards both, so the first token measured can be part of the reasoning, not the answer. Live availability is on our status page.

What a coding-agent session costs with and without the cache

Our worked example is a hypothetical coding agent. An agent loop is a program that calls the model again and again, resending the repository and the conversation each time. Each turn here sends a 60,000-token prompt and gets 3,000 tokens back, reasoning included.

Prompt caching is what changes the bill. It means that when a request starts with exactly the same text as a recent one, we reuse that start from GPU memory. A cache hit is a request that finds its start there, and we bill the reused part at the cached input price. In the example, 50,000 tokens of each prompt repeat the previous turn.

Two versions of the same 60,000-token agent prompt, drawn as 12 blocks of 5,000 tokens. With a stable start, the first 10 blocks match the previous turn and are billed at the cached rate of $0.50 per 1M tokens, the last 2 are new at $2.00: $0.045 of input. With a timestamp at the top, the first block differs, so no leading text matches and all 60,000 tokens bill at $2.00: $0.120 of input. Calculated example on DeepSeek V4 Pro 0813, prices read 21 October 2026.
In our calculated example, a stable 50,000-token start makes one DeepSeek V4 Pro 0813 turn cost $0.045 of input instead of $0.120 (prices read 21 October 2026).

All prices are in US dollars per 1M tokens, so the formula divides by 1,000,000.

cost per turn = (fresh input × input price + cached input × cached price + output × output price) / 1,000,000

For one 0813 turn with a cache hit, that is 10,000 fresh tokens at $2.00, 50,000 cached at $0.50 and 3,000 output at $4.00.

Calculated example (hypothetical inputs)0813V4 Flash 0731
One turn, nothing cached$0.132$0.016
One turn, 50,000 tokens cached$0.057$0.006
40-turn session, nothing cached$5.28$0.64
40-turn session, cached after turn 1$2.35$0.27

Caching saves 55% of the session at prices read on 21 October 2026. The cached session adds one full-price first turn to 39 cached turns.

Stacked bars for one DeepSeek V4 Pro 0813 agent turn with a 60,000-token prompt and 3,000 output tokens. Nothing cached: $0.120 fresh input plus $0.012 output, $0.132 in total. With 50,000 tokens cached: $0.025 cached input, $0.020 fresh input and $0.012 output, $0.057 in total. Input dominates the bill, so the cache is the main lever. Calculated example, prices read 21 October 2026.
One calculated DeepSeek V4 Pro 0813 agent turn costs $0.057 with 50,000 cached tokens and $0.132 without, at our prices read 21 October 2026.

The example favours caching in two ways. It assumes every turn after the first finds the cache, and it keeps the prompt at 60,000 tokens. A cache hit is best effort: we reuse a start while it is still in memory, with no guarantee. A real session also grows with every turn, so real turns cost more. The usage object of each response shows how many tokens came from the cache.

Context window and per-request limits

DeepSeek V4 Pro 0813 has a context window of 1M tokens. The context window is everything the model can read in one request: prompt, history and tools. The KV cache (key-value cache) is the record the model keeps in GPU memory of every token it has read. DeepSeek reports that at 1M tokens, V4 Pro needs 10% of the KV cache of DeepSeek-V3.2. The whole record must fit in GPU memory. For you as a caller, a smaller KV cache is what makes a 1M-token request practical to serve.

Our serverless inference docs set the limits your client has to respect.

  • Output: at most 131,072 tokens per request. A larger max_tokens is rejected with a 400 error that names the field.
  • Time: up to 300 seconds of generation per request. Stream long outputs so your client does not time out first.
  • Input: text only. A request with an image fails with a 400 error.
  • Reasoning: on by default. The reasoning trace, the text the model writes before its answer, counts as output tokens. Send reasoning_effort "none" to switch it off.
  • Tools: the standard OpenAI tools parameter works, including parallel calls. Setting tool_choice to "required" or to a named function does not force a tool call. Check message.tool_calls, and when it is empty, handle the reply as plain text or send the request again.

If answers come back empty, the reasoning probably used up max_tokens. Our guide to the empty response on a reasoning model walks through the fix.

DeepSeek V4 Pro vs V4 Flash and Kimi K3 on DeepSeek's benchmarks

The scores below are DeepSeek's own, from the DeepSeek-V4-Pro-0813 model card. DeepSeek ran the code-agent tests in its own agent framework, DeepSeek Harness, at the max reasoning effort. Each test measures how well a model completes multi-step coding or tool tasks as an agent. Treat them as vendor results, not independent tests.

Benchmark (DeepSeek's results)V4 Pro 0813V4 Flash 0731Kimi K3
Terminal Bench 2.187.982.788.3
DeepSWE62.754.467.5
Toolathlon-Verified74.170.376.5

V4 Pro 0813 sits close to Kimi K3 and ahead of V4 Flash on all three tests. Kimi K3 costs $3.00 input and $15.00 output per 1M tokens on our models page. On output-heavy agent work, V4 Pro costs less than a third of that per output token.

V4 Flash 0731 fits high-volume extraction, classification or routing. V4 Pro fits multi-step agent work and large code changes. Our comparison of Kimi K3 vs DeepSeek V4 Pro goes through reasoning tasks in detail.

How to call the DeepSeek V4 Pro API with the OpenAI SDK

You keep the official OpenAI SDK and change two values: the base URL and the API key. Set LYCEUM_API_KEY to your key, then run the request below.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LYCEUM_API_KEY"],
    base_url="https://api.lyceum.technology/openai/v1",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-pro-0813",
    messages=[{"role": "user", "content": "Summarise this diff in three bullet points."}],
    max_tokens=8192,
    stream=False,
)

print(response.choices[0].message.content)
print(response.usage)

The max_tokens of 8,192 leaves room for reasoning and the answer. The printed usage object shows input, output and cached tokens, so you can check the cache from the first day.

Choose V4 Pro when your agent needs the stronger model and your prompts repeat enough to use the cache. We recommend the 0813 ID for production agents, because our docs list its limits and behaviour. Open the DeepSeek V4 Pro 0813 model page and send your first request.

Sources

  1. DeepSeek-V4-Pro (Preview) model card, Hugging Face
  2. DeepSeek-V4-Pro-0813 model card, Hugging Face
  3. Epoch AI: Open models lag state-of-the-art closed models by 4 months (29 May 2026)