DeepSeek Agent Cost: V4 Flash and V4 Pro API Pricing for Loops

DeepSeek V4 Flash costs $0.05 per million input tokens and $0.16 per million output. On the reference 12-step agent run, which reads 172,800 input tokens and writes 4,800 output tokens, that is 172,800 × $0.05 + 4,800 × $0.16 = about $0.009. DeepSeek V4 Pro at $0.66 / $1.98 runs the same loop for about $0.12. Claude Sonnet 5 costs $0.39, GPT-5.4 $0.50 and Gemini 3.8 Flash $0.15.

The trace behind that column: a 4,000-token system prompt plus tools, a 500-token task, and twelve steps each adding a 300-token tool call and a 1,500-token result. The per-step re-send of everything before it is what makes the input column dominate; see [how much an AI agent costs to run](/guides/how-much-does-an-ai-agent-cost-to-run).

Three things about the price list matter for loops specifically.

Input is where agents spend, and V4 Flash's $0.05 input rate is 40 times below Sonnet 5 and 50 times below GPT-5.4. Output is a minor share of an agent bill, so the input rate is the one to compare.

Context is 1.3M tokens on V4 Flash and 1M on V4 Pro, so a long loop will not hit a window limit before your step cap does; a 200-step run of the reference trace ends at 362,700 tokens of context. Whether the model uses that much history well is a separate question, covered below.

Caching exists on DeepSeek's own endpoint and bills repeated prefix hits at a reduced input rate; the rate is on the vendor page and not in our catalogue, so this article prices everything uncached. If your loop re-sends a large stable prefix, the [prompt caching for AI agents](/guides/prompt-caching-for-ai-agents) rules apply to DeepSeek as well.

In our experience and in the reports we see from teams running it, V4 Flash holds up in three situations:

• Structured tool calls on well-specified tasks: a clear system prompt, tools with tight schemas and descriptive names, and a task that says what "done" looks like. Read-file, query-database, call-this-API loops fall here.
• Long-context reads: summarising or extracting from a few hundred thousand tokens of retrieved material, where the 1.3M window and the $0.05 rate combine to make a single pass cost cents.
• High-volume, low-stakes loops: classification pipelines, log triage, first-pass code review, anything where a wrong answer is cheap to detect and rerun.

V4 Pro is the same shape with more headroom on judgement, for when you want one vendor and one endpoint but a stronger planning step.

The same reports and our own use point to three weak spots. We describe them as observations, not benchmark results, because we cannot cite a benchmark that isolates them:

• Ambiguous tasks. When the brief leaves room to infer intent, V4 Flash tends to pick a literal reading and run with it, and by step 6 it has done a lot of confident work on the wrong problem.
• Long multi-turn planning. Past roughly ten steps with branching decisions, it loses track of what it has already tried and repeats tool calls. The window is large; the planning is not.
• Strict JSON edge cases. Nested optional fields, arrays of objects, unusual escaping and enum values with near-duplicates are where argument JSON comes back subtly wrong. Validate every tool call against the schema before executing it, and treat a validation failure as a signal to escalate, not to retry on the same model.

These weak spots define the boundary of the hybrid pattern below.

DeepSeek's direct API is operated by DeepSeek, and requests are processed on its infrastructure under its data policy. For some organisations that is a non-starter regardless of price, and the model's weights being open does not change where your prompts go when you call the hosted endpoint.

OpenRouter routes DeepSeek models to third-party hosting providers and lets you restrict which providers or regions serve a request, which is the practical answer to residency requirements. The trade-off is that each host sets its own rate, so an OpenRouter row for the same model can list above the direct price; the [model catalogue](/models) shows the current rows side by side. The full comparison, including caching and reliability differences, is in [OpenRouter vs direct API](/compare/openrouter-vs-direct-api).

Run the tool loop on V4 Flash and send the finished transcript to a stronger model once, to verify the work and write the final answer. The flagship reads the whole context one time instead of twelve, so its cost is bounded and small.

Reference run, eleven loop steps on V4 Flash: input 11 × 4,500 + 1,800 × 55 = 148,500 tokens, output 3,300 tokens. 148,500 × $0.05 + 3,300 × $0.16 = $0.008. Verification step, one call reading the full 24,300-token transcript and writing 1,500 tokens:

The verifier's job is narrow: check that the tool results support the conclusion and produce the final output. Give it a tool to reject the run and route rejections to a full flagship rerun; if fewer than one in ten runs is rejected, the hybrid stays far cheaper than the flagship alone. The same split scales up into the planner-and-workers layout in [multi-agent system cost](/guides/multi-agent-system-cost).

DeepSeek's API is OpenAI-compatible, so the official openai package works with a different base URL. This loop runs the tool steps on V4 Flash and computes cost from usage on every response:

import json, os
from openai import OpenAI

client = OpenAI(api_key=os.environ["DEEPSEEK_API_KEY"], base_url="https://api.deepseek.com")
MODEL = "deepseek-chat"   # confirm the id that maps to V4 Flash on the DeepSeek models page
spent = 0.0
messages = [{"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": task}]
for step in range(11):
    resp = client.chat.completions.create(model=MODEL, messages=messages, tools=TOOLS, max_tokens=1024)
    u = resp.usage
    spent += (u.prompt_tokens * 0.05 + u.completion_tokens * 0.16) / 1e6   # V4 Flash rates per 1M
    msg = resp.choices[0].message
    messages.append(msg)
    if not msg.tool_calls:
        break
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)          # validate before executing
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": run_tool(call.function.name, args)[:6000]})
# hand `messages` to the verifier model; step 12 on Sonnet 5 ≈ 24,300 × $2 + 1,500 × $10 = $0.064

Truncating tool results at 6,000 characters (roughly 1,500 tokens) keeps the trace matching the table. The [DeepSeek 101 course](/tutorials/deepseek-101) covers the endpoint basics.

For well-specified tool loops, V4 Flash is the cheapest model in the catalogue that we would trust in production, at $0.009 for the reference run. Gemini 3.8 Flash at $0.15 is the next step up with a different failure profile, and Claude Haiku 4.5 at $0.20 sits just behind it; the ranking across all of them is in [cheapest LLM for AI agents](/guides/cheapest-llm-for-ai-agents).

Pay for a flagship on the whole loop, not just the last step, when the task is ambiguous from step one, when the loop needs more than ten steps of real planning, or when a wrong answer costs more than the $0.38 you save. Claude Opus 5 at $0.98 or GPT-5.5 at $1.01 for the reference run is still cheap next to one bad decision.

Cheap loops run unwatched, which is how a 200-step loop happens. At V4 Flash rates a 200-step runaway is about $1.85, so nobody notices until it runs on ten thousand tasks. Keep the same four controls you would use on Sonnet 5:

• max_tokens per call, 1,024 for tool steps
• A step cap, 12 to 25, enforced in the loop
• A stop condition: end on a response with no tool_calls, and abort on a repeated identical call
• A per-run dollar budget summed from usage.prompt_tokens and usage.completion_tokens, plus the verifier's usage

The runner in [token budget guardrails](/guides/ai-agent-token-budget-guardrails) does this for Anthropic and ports to this endpoint by swapping the usage field names. Price your own trace across vendors in the [calculator](/calculator).