If you are trying to budget a high-volume LLM workload, the hardest part is not picking a model — it is getting a straight answer on what a model actually costs. Provider pages quote different numbers, "per million tokens" hides the input/output split, and a headline rate tells you nothing about what a real job will bill. This guide fixes that for DeepSeek V4 Flash pricing: the first-party rates, where third-party providers diverge, worked cost examples for real jobs, and an honest price-per-token comparison against GLM 5.2 and other cheap models.
The numbers here are drawn from DeepSeek's official pricing documentation and cross-checked against independent price trackers (Artificial Analysis, OpenRouter, and other aggregators) as of August 2026. Model prices change often, so treat the official DeepSeek pricing page as the source of truth before you commit a production budget. This article is written by the GLM 5 Team, which runs cost-sensitive inference workloads daily, so the examples reflect how token bills actually accumulate rather than a spec-sheet readout.
What This Article Solves
The pain point is simple: you cannot plan spend from a headline number alone. A rate of "$0.14" means nothing until you know whether it is input or output, per how many tokens, from which provider, and how that maps to your traffic. Below you get the locked first-party rate, the provider spread, and math you can copy for your own volumes — so you can decide whether DeepSeek V4 Flash is the cheapest fit or whether a stronger model like GLM 5.2 is the better value once quality enters the equation.
DeepSeek V4 Flash: First-Party Pricing
DeepSeek V4 Flash is the efficiency tier of the DeepSeek V4 family, released on 2026-04-24 under an MIT open-weight license. It is a Mixture-of-Experts model with 284B total parameters and roughly 13B activated per token, tuned for speed and low cost on everyday work — coding assistants, chat, and high-volume agentic tasks — rather than for the deepest reasoning (its sibling DeepSeek V4 Pro covers that flagship role).
Per DeepSeek's official API pricing, the first-party rate for deepseek-v4-flash is:
| Direction | Price per 1M tokens |
|---|---|
| Input | $0.14 |
| Output | $0.28 |
That 1:2 input-to-output ratio is standard for this class of model, and it matters for budgeting: output tokens cost twice as much, so verbose responses inflate bills faster than long prompts. DeepSeek's pricing page also notes that peak/off-peak rules can apply, with peak pricing potentially higher than the base rate once such policies take effect — always confirm current terms on the official DeepSeek pricing page before locking a forecast.
Provider Variation (Read This Before You Quote a Number)
DeepSeek V4 Flash is open-weight, so third-party inference providers host it too — and their prices differ from DeepSeek's own API. For example, DeepInfra has listed the model around $0.10 / 1M input and $0.20 / 1M output, which is cheaper than first-party. Other aggregators sit at or above the first-party rate depending on throughput guarantees, region, and context-length handling.
Two rules keep you out of trouble:
- Label the source. "$0.10 input" is only true on a specific provider; it is not "the DeepSeek V4 Flash price." When you report a number, name the provider.
- Price the whole request, not the cheapest half. A provider that undercuts on input but not output can cost more on output-heavy traffic. Compare on your real input:output ratio.
For a live cross-provider snapshot, independent trackers like Artificial Analysis and OpenRouter list current per-provider rates side by side.
Cost Examples: What a Real Job Actually Bills
Headline rates get concrete once you run the arithmetic. All figures below use the first-party rate ($0.14 input / $0.28 output per 1M tokens).
Example 1 — A 1M-token input, 1M-token output job. Input: 1M × $0.14 = $0.14. Output: 1M × $0.28 = $0.28. Total: $0.42 for two million tokens processed. Even a full million tokens each way costs less than a coffee.
Example 2 — A mostly-read batch (summarization / extraction). Say you process 50M input tokens and generate 5M output tokens in a day. Input: 50 × $0.14 = $7.00. Output: 5 × $0.28 = $1.40. Total: $8.40/day, or about $252/month for a steady pipeline.
Example 3 — A chat/agent workload (balanced I/O).
100,000 requests, each ~2K input and 500 output tokens. Input: 200M × $0.14 = $28.00. Output: 50M × $0.28 = $14.00. Total: $42.00 for 100K requests. On a provider like DeepInfra ($0.10/$0.20), the same job runs ~$20 + $10 = $30 — a ~29% saving, which is exactly why provider choice matters at scale.
The takeaway: DeepSeek V4 Flash is genuinely cheap, and output volume — not the headline input rate — is the lever that moves your bill. Cap max_tokens, trim system prompts, and the cost drops further.
DeepSeek V4 Flash vs GLM 5.2 and Other Cheap Models
Price-per-token only tells half the story. The other half is how many tokens and retries you spend to actually finish the task. A cheaper model that needs two passes on a hard coding job can cost more than a pricier model that nails it once. Here is an honest side-by-side on the pricing itself:
| Model | Input / 1M | Output / 1M | Tier / best fit |
|---|---|---|---|
| DeepSeek V4 Flash | $0.14 | $0.28 | Cheapest tier; high-volume, low-latency everyday work |
| DeepSeek V4 Flash (DeepInfra) | ~$0.10 | ~$0.20 | Provider-specific; even cheaper, verify current rate |
| GLM 5.2 | ~$1.40 | ~$4.40 | Flagship-grade coding/agentic depth at frontier value |
| DeepSeek V4 Pro | Higher (flagship tier) | Higher | Deep reasoning sibling; confirm on official page |
GLM 5.2 costs about 10x more per input token than DeepSeek V4 Flash — and that is the point of the comparison, not a knock on either. They sit in different tiers on purpose:
- Choose DeepSeek V4 Flash when raw cost and speed dominate: high-volume summarization, classification, cheap chat, and agentic loops where "good enough, fast, cheap" wins. At $0.14/$0.28 it is one of the lowest-cost capable models you can call.
- Choose GLM 5.2 when quality and agentic depth are the constraint, not the token price. GLM 5.2 is Zhipu AI's flagship — roughly 750B total MoE with ~40B active, a 1M-token context window, MIT open-source, and strong coding and agentic performance. On a hard SWE-bench-style task or a multi-step tool-using agent, the model that finishes correctly in one pass is often the cheaper outcome even at a higher per-token rate. If your workload is dominated by depth rather than volume, try GLM 5.2 on glm5.app and price it on results, not just the rate card. Full plan details are on the GLM 5.2 pricing page.
The most reliable way to decide is to run your own prompts through both and compare total cost-to-done, not headline rates.
How to Judge a Model's Real Price
When you evaluate any cheap model, score it on four things, not one:
- Split rate, not headline. Always separate input and output pricing; a 1:2 or 1:4 ratio changes the math for output-heavy work.
- Provider and region. Open-weight models vary by host. Lock the provider before quoting a number.
- Tokens-to-done. Count retries and failed passes. A model that needs fewer attempts on your task can be cheaper overall.
- Hidden multipliers. Peak pricing, minimum context billing, and cache behavior can move the effective rate well above the sticker price.
Edge cases and limitations: the numbers here are first-party rates as of August 2026 and are subject to change; peak/off-peak policies and provider-specific rates can shift the effective cost; and DeepSeek V4 Flash is non-reasoning by default, so reasoning-heavy tasks may spend more output tokens (or need Pro), narrowing the gap versus a stronger model. Verify every figure against the linked official sources before you commit a budget.
Bottom Line
DeepSeek V4 Flash pricing is straightforward once you separate the layers: first-party $0.14 input / $0.28 output per 1M tokens, with select third-party providers (e.g., DeepInfra ~$0.10/$0.20) running cheaper — always labeled as provider-specific. A full 1M-in / 1M-out job costs about $0.42, and a 100K-request chat workload lands near $42. That makes it one of the best price-per-token options for high-volume, cost-sensitive work.
But the cheapest rate card is not always the cheapest result. When your workload leans on coding depth or agentic reasoning, a flagship like GLM 5.2 often wins on cost-to-done despite the higher per-token price. Put both on your real prompts: test GLM 5.2 free on glm5.app and check the GLM 5.2 pricing page to see where the value lands for your stack.
Sources
- DeepSeek Models & Pricing — Official first-party token pricing, model IDs, context length, and peak/off-peak notes for
deepseek-v4-flash. - DeepSeek Your First API Call — Official base URL, supported model IDs, and OpenAI-format request examples.
- DeepSeek Chat Completions API — Official request schema, model IDs, and token accounting behavior.
- DeepSeek Platform — Official account, billing, and API key management.
- DeepSeek-AI on Hugging Face — Official open-weight model card, license (MIT), and architecture details.
- Artificial Analysis — DeepSeek V4 Flash — Independent benchmark authority and cross-provider price/performance tracking.
- OpenRouter — DeepSeek V4 Flash — Independent per-provider pricing and availability snapshot.
- DeepInfra Pricing — Example third-party provider rate used for provider-variation comparison.
- GLM 5.2 pricing — Official GLM 5.2 plan and per-token pricing for the flagship comparison.
- Zhipu AI — Official developer of GLM 5.2, the flagship model referenced in the comparison.