DeepSeek V4 Flash vs Gemini 3.6 Flash: Tied Score, 10x Price

TL;DR: DeepSeek V4 Flash 0731 and Gemini 3.6 Flash both land on 50 on the Artificial Analysis Intelligence Index v4.1, with GPT-5.6 Luna one point ahead at 51. Their list prices span more than an order of magnitude. The interesting part is what happens when you stop comparing price tags and start comparing invoices for the same evaluated workload. Artificial Analysis publishes what it paid to run each one: $72.02 for DeepSeek, $190.87 for Luna, $726.70 for Gemini. The sticker gap on output price is 27x. The gap on the actual bill is 10.1x, because DeepSeek burned 210M output tokens on that run to Gemini’s 59M. Both numbers say buy DeepSeek if your workload is text; neither of them survives contact with a pipeline that sends images.

TL;DR: Which One Should You Pick?

Two ways to stop reading here. If your workload sends any non-text input, the second row settles it and the rest of this article is background. If your workload is text and runs under about 20M tokens a month, the annual difference between the cheapest and most expensive option above is smaller than a day of engineering time, so pick on latency and move on. Everything below is written for the case where the bill is large enough to argue about.

What Actually Changed on July 31

DeepSeek shipped a new build of V4 Flash on 2026-07-31 and did not change the model. Same 284B total parameters, same 13B active, same 1M context, same $0.14 / $0.28 price. The API model name is unchanged too, deepseek-v4-flash, with the build identified in DeepSeek’s docs as model version DeepSeek-V4-Flash-0731. What changed is post-training.

The measured effect is larger than “post-training only” usually implies. On the Artificial Analysis Intelligence Index v4.1, the score went from 40 to 50. AA’s agentic evaluation, GDPval-AA v2, moved from 1189 Elo to 1559. Terminal-Bench 2.1 gained 17 points to reach 79%. AA also places the 0731 build 6 points ahead of DeepSeek V4 Pro, DeepSeek’s own flagship, which is an awkward result for anyone who wrote routing rules on the assumption that Pro handles the hard cases.

We were among those people. Our DeepSeek V4 Pro vs Flash routing guide from May concluded that multi-file work and long agent loops belonged on Pro. For the 0731 build that conclusion no longer holds, and the honest version is that Flash is now the default and Pro is the exception you justify.

The weights landed faster than anyone said they would. AA’s launch coverage described full weights as expected “in the coming weeks”, and most secondary coverage still repeats that. Checked on 2026-08-01, deepseek-ai/DeepSeek-V4-Flash-0731 on Hugging Face already carries the model as 48 safetensors shards under MIT, ungated. If you read somewhere that 0731 is API-only, that was true for about a day.

One caveat worth stating before the numbers start. The Intelligence Index is a rolling leaderboard, and everything below is a 2026-08-01 snapshot. Treat the ordering as the durable fact and the absolute score as a reading taken on a particular day.

Quick Specs Comparison

Two rows deserve a second look. Max output is a real separator: 384K against 64K is the difference between generating a long file in one call and building a continuation loop. And the empty latency cells are not a formatting accident. AA’s provider page for the 0731 build listed no speed or time-to-first-token data at the 2026-08-01 snapshot, so anyone quoting you a tokens-per-second figure for this build is quoting something else.

The Benchmark Picture: One Point Separates Three Models

Here is the AA sub-score detail for the 0731 build, with the delta against the April build where AA published one.

The Omniscience row is the one people skip. AA reports that the improvement came from fewer hallucinations rather than from knowing more, with accuracy flat. For a model you are about to point at production traffic, “wrong less often” is a more useful upgrade than “knows more”, and it is the sort of thing a single composite score hides.

Two sourcing notes, because this release has more than one set of numbers floating around.

DeepSeek’s own release materials report Terminal-Bench 2.1 at 82.7, DeepSWE at 54.4 and Cybergym at 76.7. Artificial Analysis reports Terminal-Bench 2.1 at 79%. Both can be correct; harnesses, scaffolds and effort settings differ, and there was no third-party reproduction of the DeepSWE and Cybergym figures at snapshot time. We are using AA’s numbers throughout because they are the only ones measured the same way across all three models here. If you see 82.7 quoted somewhere, that is the vendor’s harness, not a contradiction.

The other one: the LMArena score attached to DeepSeek V4 Flash on most catalog pages, including ours, reads 1438 Overall with a rank in the seventies, updated 2026-07-12. That predates the 0731 build by nineteen days. It measures the April model. Arena scores for the new build will need new votes, and until then the number sitting next to “DeepSeek V4 Flash” on any comparison page is describing a model that scored 10 points lower on AA.

The Verbosity Tax: Why the Sticker Gap Is Not the Bill Gap

Every comparison of these two models leads with $0.14 against $1.50 and stops there. That ratio is real, and it is also the least reliable number in this article, because it prices a token rather than a job.

Artificial Analysis publishes something better: what it actually paid to run each model through the same Intelligence Index suite, invoice included.

Same evaluation, three real bills. Gemini costs 10.1x what DeepSeek costs, and Luna 2.7x. Against the sticker ratios of 27x and 4.3x on output price, that is roughly 60% of DeepSeek’s paper advantage disappearing somewhere between the price card and the invoice.

Where it goes is tokens. DeepSeek spent 210M output tokens on that suite against Gemini’s 59M, which AA flags as very verbose against the field. Price the output leg alone at list rates and you get $58.80 for DeepSeek, $156.00 for Luna and $442.50 for Gemini, a 7.5x gap on that leg. The shape of the two bills differs accordingly: output is about 82% of what DeepSeek’s run cost and about 61% of Gemini’s. That is the signature of a model that writes three and a half times as much to reach the same score. AA does not publish input token counts per model, so the remainder is not decomposable any further from published figures.

Which number you plan against depends on your traffic. A workload that is mostly prompt tracks the input ratio, 10.7x. A workload that is mostly generation gets compressed toward 7.5x by the verbosity. AA’s end-to-end figure of 10.1x sits between them, on a suite that is itself a mix, which is why 10x is a better default than 27x for anything you have to defend in a budget review.

Two caveats on the token counts. They come from AA’s max-effort and high-effort configurations, which is the expensive end of each model’s range rather than a typical production setting. And verbosity is workload dependent; a suite full of hard reasoning problems flatters models that reason briefly, and your extraction pipeline is not that suite.

One footnote on the 210M, since two AA numbers circulate. The model page reports 210M output tokens for the index run; AA’s launch article reports ~206M, alongside the more interesting fact that this is 12% fewer output tokens than the previous V4 Flash build spent (~234M). So 0731 is both more verbose than its peers and less verbose than its own predecessor. We use 210M throughout because the model-page figure is the one published the same way for all three models here.

The lever, though, is real and it is one flag. DeepSeek’s docs list deepseek-v4-flash as supporting both non-thinking and thinking modes, with thinking as the default, and reasoning tokens bill as output. For bounded work, turning thinking off is where the verbosity tax goes away.

Measure it on your own traffic

AA’s ratio is a starting estimate, not your number. Getting your own takes one run over a sample of your real prompts, because every OpenAI-compatible response carries the token counts you need:

import collections
from openai import OpenAI

client = OpenAI(base_url="https://api.ofox.io/v1", api_key="YOUR_OFOX_API_KEY")

costs = {  # input, output, per 1M tokens
    "deepseek/deepseek-v4-flash": (0.14, 0.28),
    "google/gemini-3.6-flash": (1.50, 7.50),
    "openai/gpt-5.6-luna": (0.20, 1.20),
}
totals = collections.defaultdict(float)

for prompt in load_your_real_prompts():        # 50 is enough to see the shape
    for model, (pin, pout) in costs.items():
        u = client.chat.completions.create(
            model=model, messages=[{"role": "user", "content": prompt}]
        ).usage
        totals[model] += (u.prompt_tokens * pin + u.completion_tokens * pout) / 1e6

for model, spend in sorted(totals.items(), key=lambda kv: kv[1]):
    print(f"{model:32} ${spend:.4f} over the sample")

Fifty representative prompts cost a few cents to run across all three and will tell you more than any leaderboard. Two things to watch for. Run it twice with thinking on and off for DeepSeek, since that flag moves the output column more than the model choice does. And sample from your actual traffic distribution rather than your hardest cases, because verbosity ratios measured on hard reasoning problems do not transfer to a queue full of two-line classifications.

Pricing Math: Two Real Monthly Bills

All prices below are vendor list, snapshot 2026-08-01, per 1M tokens.

Scenario A, an extraction pipeline. 200M input tokens and 10M output tokens per month, no caching, short structured outputs.

Input dominates, so this scenario tracks the input-price ratio closely: Gemini costs 12x DeepSeek, Luna 1.7x. Note how much the July 30 price cut changed Luna’s position here. At the old $1 / $6 the same workload was $260 a month.

Scenario B, a coding agent loop. 100M input tokens at a 70% cache hit rate and 40M output tokens per month.

That table holds tokens constant, which quietly assumes all three models write the same amount to do the same job. They do not. Holding the work constant instead, and scaling output by the verbosity ratios from the index run, gives a fairer picture of the same agent loop:

DeepSeek goes from 23x cheaper to 8x cheaper. The decision does not change. The number you put in a slide should.

For the deeper version of this arithmetic on DeepSeek specifically, including what cache misses do to a real bill, see our V4 Pro cost breakdown and the DeepSeek V4 API pricing guide.

Two Pricing Details That Will Move Your Bill

DeepSeek is about to introduce peak-hour pricing. Its pricing docs carry a footnote: the API will adopt a peak/off-peak policy under which peak-hour prices are 2x regular prices, applicable to all billing items, with the effective date pending official announcement. The peak windows are 09:00 to 12:00 and 14:00 to 18:00 Beijing time, UTC+8.

Translate that to your own clock before you assume it is harmless. Those windows land at 21:00 to 00:00 and 02:00 to 06:00 US Eastern, which is the middle of the night for a US-daytime workload, and at 03:00 to 06:00 and 08:00 to 12:00 Central European, which eats a European team’s entire morning. If you run in Europe and DeepSeek turns this on, your $0.14 becomes $0.28 for the first half of the working day. That is still under Gemini, but it is not the number you budgeted.

The route you buy through can differ from the vendor’s list price. OpenAI cut GPT-5.6 Luna by 80% on 2026-07-30, from $1 / $6 to $0.20 / $1.20. Listings that serve Luna through Azure had not moved at the 2026-08-01 snapshot, including ours, where openai/gpt-5.6-luna is an Azure route showing $1 / $6 list. Same model ID, 5x apart, purely on which upstream you land on.

Two footnotes on that table. Our Luna listing was running a 20% promotion at snapshot, which takes the Azure route to an effective $0.80 / $4.80, still four times the OpenAI list price. And the cache-read column deserves its own look: on the Azure DeepSeek route, cache reads cost the same as fresh input, which deletes the single largest cost advantage this model has.

The general rule the table teaches: check the route, not the model name. A price cut announced by a lab reaches that lab’s own API immediately and everyone else on their own schedule. Two of the seven rows above are the same model at very different money.

What Text-Only Actually Costs You

The cheapest model in this comparison cannot see. DeepSeek V4 Flash 0731 accepts text, calls functions, returns JSON and speaks both the OpenAI and Anthropic wire formats, and that is the whole list. Gemini 3.6 Flash takes text, image, video, audio and PDF. GPT-5.6 Luna takes text and image.

This is not a quality gap you can close with prompt engineering or a bigger budget. If your pipeline sends screenshots of a broken UI, scanned invoices, or frames from a video, the DeepSeek call does not fail gracefully at a higher price. It fails structurally. Every cost table above becomes irrelevant for that class of work, which is why the modality row sits near the top of the specs table rather than buried at the bottom.

A common resolution is to split the traffic: multimodal requests to Gemini, everything else to DeepSeek, one router in front. That is more work than picking one model, and for a pipeline where 90% of requests are text it usually pays for itself in the first month.

When to Pick DeepSeek V4 Flash 0731

Text-only workloads at volume, where the bill is a real line item. Anything with a high cache hit rate benefits disproportionately, because $0.0028/M cache reads are a 98% discount on fresh input, a 50x reduction. Long single generations favor it as well: 384K max output is six times Gemini’s ceiling. It is also the only one of the three with published weights, MIT-licensed on Hugging Face, so if the plan is to prototype on an API and self-host later, this is the one with a path.

Turn thinking off for bounded work. It is the difference between the $15.60 and the $44.16 rows above.

When to Pick Gemini 3.6 Flash

Whenever a non-text modality is involved, which settles it before price enters the conversation. Also when latency is user-visible: 219.6 output tokens per second put it third of 185 models on AA’s speed ranking at snapshot, and 15.11 seconds to first token is fast for a reasoning model. And when you want a third party to have measured the thing you are about to depend on, since AA has published speed and latency for Gemini and had not for the 0731 build.

The batch tier is underrated. At $0.75 / $3.75 for work that tolerates delay, Gemini’s effective distance from DeepSeek halves.

When to Pick GPT-5.6 Luna

When you want the highest index score of the three and vision in the same model, and the 80% price cut has made that combination affordable in a way it was not three weeks ago. Luna at $0.20 / $1.20 is now closer to DeepSeek than to Gemini on price while scoring a point higher than both.

Two things to check first. The 121.89 second time to first token that AA measured is the max-effort configuration, and max effort is not an interactive setting; if you use Luna in a UI, use a lower effort level. And confirm which route your gateway puts you on, because the pre-cut Azure tier is 5x the OpenAI list price. Our GPT-5.6 tier guide covers how Sol, Terra and Luna divide the work.

When None of the Three Is the Right Answer

If your workload is small, none of this matters. At a few million tokens a month the difference between the cheapest and most expensive option here is a rounding error against an hour of engineering time, and you should pick on capability and move on.

If you are chasing zero, a hosted API is the wrong tool. The free and self-hosted paths for this model family are a separate exercise with real caps attached, covered in DeepSeek V4 Flash free: four zero-cost paths. Those paths were verified against the build that preceded 0731, so recheck the caps before relying on them. The self-host route has changed since: the 0731 weights are now on Hugging Face under MIT, so the license-free option applies to the current build rather than the April one.

And if the job is deep multi-step agentic work with tool calls in the double digits, none of these three flash-tier models is an obvious fit. That is frontier-tier territory, and the honest answer is to benchmark on your own traces rather than on anyone’s index. Our earlier Gemini Flash Lite vs DeepSeek V4 Flash agent-loop comparison walks through how tool-call reliability changes the math at depth.

Try All Three via ofox: A/B in One Loop

All three run on one OpenAI-compatible endpoint, so the comparison is a string swap rather than three integrations. The model IDs are deepseek/deepseek-v4-flash, google/gemini-3.6-flash and openai/gpt-5.6-luna.

Python

from openai import OpenAI

client = OpenAI(base_url="https://api.ofox.io/v1", api_key="YOUR_OFOX_API_KEY")

MODELS = [
    "deepseek/deepseek-v4-flash",
    "google/gemini-3.6-flash",
    "openai/gpt-5.6-luna",
]

prompt = "Refactor this function to remove the nested loop. Return only code."

for model in MODELS:
    r = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    u = r.usage
    print(f"{model:32} in={u.prompt_tokens:6} out={u.completion_tokens:6}")

Log completion_tokens and not just latency. That column is where the verbosity difference shows up on your own traffic, and it is the number the sticker price does not tell you.

Node

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.ofox.io/v1",
  apiKey: process.env.OFOX_API_KEY,
});

const models = [
  "deepseek/deepseek-v4-flash",
  "google/gemini-3.6-flash",
  "openai/gpt-5.6-luna",
];

for (const model of models) {
  const r = await client.chat.completions.create({
    model,
    messages: [{ role: "user", content: "Summarize this changelog in 3 bullets." }],
  });
  console.log(model, r.usage.prompt_tokens, r.usage.completion_tokens);
}

The call DeepSeek cannot run

Same client, same endpoint, one content block that changes everything. Send this to google/gemini-3.6-flash or openai/gpt-5.6-luna and you get an answer. Send it to deepseek/deepseek-v4-flash and there is no price at which it works.

import base64

img = base64.b64encode(open("screenshot.png", "rb").read()).decode()

r = client.chat.completions.create(
    model="google/gemini-3.6-flash",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Which element is misaligned?"},
            {"type": "image_url",
             "image_url": {"url": f"data:image/png;base64,{img}"}},
        ],
    }],
)
print(r.choices[0].message.content)

Alternatives

If none of the three fits, the neighbors worth checking are on the same endpoint. DeepSeek V4 Pro at $0.435 / $0.87 list, which the ofox listing rounds to $0.45 / $0.88, is now the more expensive and lower-scoring sibling on AA’s index, though it remains the right call if you have workload-specific evidence that it wins on your traces. GPT-5.6 Terra sits above Luna when the flash tier is genuinely not enough. Outside the ofox catalog, the same models are available first-party from DeepSeek, Google AI Studio and the OpenAI API, which is the right choice if you only ever need one vendor and want the price cut the day it lands rather than whenever the route catches up.

Model pages with live pricing: DeepSeek V4 Flash, Gemini 3.6 Flash, GPT-5.6 Luna.

Sources

• https://artificialanalysis.ai/articles/deepseek-v4-flash-0731-scores-50-on-the-artificial-analysis-intelligence-index-10-points-above-previous-deepseek-v4-flash
• https://artificialanalysis.ai/models/deepseek-v4-flash
• https://artificialanalysis.ai/models/gemini-3-6-flash
• https://artificialanalysis.ai/models/gpt-5-6-luna
• https://api-docs.deepseek.com/quick_start/pricing
• https://ai.google.dev/gemini-api/docs/pricing?hl=en
• https://docs.cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/3-6-flash
• https://developers.openai.com/api/docs/pricing
• https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash-0731