GPT-6 Luna vs Gemini 3.8 Flash vs DeepSeek: What the Sub-$1 API Tier Actually Costs

You have an endpoint that classifies support tickets, or pulls three fields out of a webhook payload, or writes a one-line summary of a log entry. It runs a few million times a month. The quality bar is “good enough and consistent”, and the only number your finance team cares about is the bill.

Until 2026-09-22 that bracket belonged to Google’s Flash line and to DeepSeek. Then OpenAI shipped GPT-6 Luna at $0.10 per million input tokens and $0.50 per million output tokens, with a 1M context window, and the bracket got crowded.

The catch is that the three headline prices are not the same kind of number. One is a cut measured against a promotion. One expires on a calendar date. One changes depending on what time of day your job runs. Line them up as printed and you will pick the wrong model.

The published prices, as of 2026-09-23

Luna and DeepSeek prices come from each vendor’s own pages. The Gemini row comes from Google’s API pricing page, paid tier.

On flat per-token input, Luna is 7.5x cheaper than Gemini 3.8 Flash and 3x cheaper than DeepSeek Flash at peak. On output it is 7.5x and 2.4x. That is the entire story if you never cache and never read the footnotes. Three footnotes follow, and every one of them can flip a decision.

Asterisk one: OpenAI’s cut is measured against a promotional rate

OpenAI says Luna and its larger sibling Sol are 50% cheaper than GPT-5.6 promotional pricing. “Promotional” is OpenAI’s own word and it belongs in every repetition of that claim.

Our launch coverage recorded GPT-5.6 Luna’s list price at $1.00 input and $6.00 output. Measured against list rather than against the promo, GPT-6 Luna’s $0.10 and $0.50 are a 90% cut on input and a 92% cut on output. The real move is larger than the headline. The headline is just anchored to a discount.

What this means operationally: the $0.10 and $0.50 are published as Luna’s prices, not as a promotion, so plan around them. But do not treat “50% cheaper than GPT-5.6 promotional pricing” as a like-for-like generational comparison, because it is not one. If you are migrating, see what is GPT-6 Luna and the predecessor tier breakdown in GPT-5.6 Sol vs Terra vs Luna.

Asterisk two: the Gemini Flash price has an expiry date

Google’s pricing page prints both numbers in the same cell. Gemini 3.8 Flash is $0.75 input and $3.75 output “through December 31, 2026”, then $1.50 and $7.50 “starting January 1, 2027”. Context caching follows the same shape, $0.075 now and $0.15 in January. Gemini 3.7 Flash and 3.6 Flash carry identical rows.

If you are building a 12-month cost model on Flash this week, three of those months are priced at double. A team that budgets $60k of Flash spend for next year on today’s rate is budgeting for roughly $90k of actual invoices, assuming flat volume. That is not a rounding error.

Two related facts from the same page. There is no Gemini 3.8 Flash-Lite or 3.7 Flash-Lite listed. The cheapest Flash-Lite entries that remain are Gemini 3.5 Flash-Lite at $0.30 input and $2.50 output, and Gemini 2.5 Flash-Lite at $0.10 input and $0.40 output. That last row is the only entry in this whole comparison that undercuts Luna on output, and it is two generations old.

Asterisk three: DeepSeek’s price depends on the clock

DeepSeek publishes peak and off-peak columns. Peak applies 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday through Friday, excluding Chinese public holidays. Off-peak is half of peak across the board. For deepseek-flash, that is $0.30 versus $0.15 on cache-miss input and $1.20 versus $0.60 on output.

For a nightly batch this is free money: move the cron outside the window and halve the bill. For interactive global traffic it is a modelling headache, because your effective rate is a blend you cannot quote until you have measured your own request distribution against the UTC clock. If DeepSeek is a serious candidate, log a UTC timestamp alongside token counts on every call, or your cost model is a guess wearing a spreadsheet.

Our earlier breakdown of that pricing structure is in DeepSeek-V4.1-Flash pricing.

Where the tiers really separate: cached input

DeepSeek’s cache hit is the cheapest input number anywhere in this comparison, 50x below its own miss price. Its miss price is also 3x Luna’s flat rate. So DeepSeek pays out spectacularly for a workload with a long stable prefix and penalises one that sends a fresh prompt every time. Luna’s ratio is flatter, which mostly means fewer ways to get it badly wrong.

GPT-6 also shipped a real caching release rather than a price line. Higher hit rates by default, a 90% discount on cached input reads, a Prompt Caching Dashboard and a diagnostics tool, explicit breakpoints so you choose where the cached prefix ends, and, most usefully, changing reasoning effort or tool availability no longer invalidates the cache. GitHub reports more than 50% fewer prompt tokens needing fresh processing across billions of requests. If you have ever watched a hit rate collapse because somebody flipped one tool on, you know what that property is worth. More on it in the GPT-6 prompt caching release.

Per token is the wrong unit

OpenAI published cost per task alongside accuracy, which is the more honest framing. On DeepSWE 1.1, Luna at max reasoning scores 66.6%, which OpenAI describes as comparable to Claude Opus 5 and Fable 5 at medium effort, at 93% lower cost per task than Opus 5 and 96% lower than Fable 5. On OSWorld 2.0 offline, Luna at max beats GPT-5.6 Sol at medium for about a tenth of the cost. On factuality, Luna at higher effort matches GPT-5.6 Sol at roughly a hundredth of the cost. Against its own predecessor on AutomationBench 1.0.6, Luna at high effort scores 5.4 points better at 58% lower cost per task.

Now the part that matters more than any of it: neither Google nor DeepSeek publishes cost-per-task figures on these benchmarks for Gemini 3.8 Flash or deepseek-flash. So this article is a three-way price comparison plus one vendor’s own cost-per-task claims about itself. It is not a three-way agentic leaderboard, and anyone showing you one for this tier is either running a third-party harness they should be naming or inventing numbers.

The reason per-token comparison misleads is reasoning tokens. A model that bills 3x less per token and emits 5x more tokens to finish the same job costs you more. Output tokens including thinking are what you actually pay for, and only your own workload knows that ratio.

The latency trap

Artificial Analysis, a third party rather than either vendor, measures GPT-6 Luna at 153.9 output tokens per second with a time to first token of 124.23 seconds, and GPT-6 Sol at 115.2 tokens per second at 102.15 seconds. Those figures are for the “max” reasoning variants, so read them as a ceiling and not as what you would see at default effort. Treat both as unverified against first-party data.

The direction is still the point. In this generation the cheap model is not the fast model. Two minutes to first token is perfectly fine for an overnight enrichment job and completely unusable behind a chat box. If your endpoint is user facing, time to first token at your chosen effort level decides the question, not dollars per million.

Measure it yourself: one request, three environments

All three providers accept an OpenAI-shaped chat completions call, so you do not need three clients.

Build the request once, put base_url, model_id and api_key in an Apidog environment, then switch environments to fire the same saved request at each provider. No copy-pasted curl, no drift between the three versions of your prompt.

POST {{base_url}}/chat/completions
Authorization: Bearer {{api_key}}
Content-Type: application/json

{
  "model": "{{model_id}}",
  "messages": [
    {"role": "system", "content": "Extract order_id and status. Reply with JSON only."},
    {"role": "user", "content": "{{ticket_body}}"}
  ]
}

Apidog runs Postman-compatible post-response scripts, so assert on shape and latency and log the usage block in the same pass:

pm.test("content parses as the JSON we asked for", () => {
  const parsed = JSON.parse(pm.response.json().choices[0].message.content);
  pm.expect(parsed).to.have.property("order_id");
});

pm.test("first byte to last byte under 3s", () => {
  pm.expect(pm.response.responseTime).to.be.below(3000);
});

console.log(pm.response.json().usage);

Then run the same 200 real payloads through each environment and record four things per call: usage.prompt_tokens, usage.completion_tokens, response time, and whether the assertion passed. Multiply the token counts by the price table above and divide by your pass count. That gives cost per correct answer, which is the only figure that decides anything. Run the DeepSeek pass twice, once inside the UTC peak window and once outside it, or you have measured half a price.

What to reach for

That last row has its own piece: GPT-6 Luna for high-volume API workloads.

Bottom line

GPT-6 Luna is the cheapest flat, unconditional, no-footnote price in the sub-$1 tier right now, and it brings a 1M context window with it. DeepSeek Flash beats it on cached input by a wide margin and loses badly on cache misses. Gemini 3.8 Flash is the most expensive of the three today and will be twice that in January.

None of which tells you what to ship. Run your own payloads through all three, measure cost per correct answer and time to first token, and re-run it when the next launch lands, which on the current cadence will be inside a month. For the wider picture of what changed in the last week of September, see the AI model price war of September 2026.