Why I priced it by the task, not the token
I build integrations and APIs for a living, and the first thing I do with any new model is read the usage object it sends back. A per-million-token rate is the sticker. What you actually pay depends on how many tokens one job burns, how many of them are cached, and how many are reasoning tokens you never see. So for this post I priced Mercury 3 the way I'd price it before wiring it into anything: per task, at launch and at list, against the models it's chasing.
There's a second reason I look at it this way. eesel has spent years running AI models on live support queues, and the per-token bill has never been the expensive part of those rollouts. The expensive part is everything around the model. I'll come back to that at the end, with real numbers from one of our customers.
If you want the speed and benchmark story first, my Mercury 3 overview covers what the model is and how fast it runs. This post is only about the money.
How much does Mercury 3 cost?
Here's Inception's own rate card, from the models page and the model docs, checked on 20 October 2026.
| Model | Input (list → launch) | Cached input | Output (list → launch) | Context | Max output |
|---|---|---|---|---|---|
| Mercury 3 | $0.20 → $0.10 | $0.02 → $0.01 | $0.70 → $0.35 | 1M | 131,072 |
| Mercury Voice | $0.40 → $0.20 | $0.04 → $0.02 | $1.50 → $0.75 | 128K | 50,000 |
| Mercury Decide | $0.04 → $0.02 | $0 | $0 (not billed) | n/a | n/a |
| Mercury Edit 2 | $0.25 | $0.025 | $0.75 | 32K | 8,192 |
| Mercury 2.5 (closing) | $0.20 | $0.02 | $0.75 | 260K | 65,536 |
| Mercury 2 (closing) | $0.25 | $0.025 | $0.75 | 128K | 50,000 |
All prices are per million tokens. A few things the table doesn't say on its own:
- The billable unit is plain tokens. Inception's FAQ says reasoning tokens are counted inside completion tokens and billed at the output rate, and cached tokens are a subset of prompt tokens billed at the cached rate. There's no per-request fee.
- Reasoning effort is per request. Mercury 3 takes
instant,low,mediumorhigh, and per the reasoning docs it defaults tolowif you don't set it. Inception's own benchmarks were all run at medium, so if you copy their settings, expect more output tokens than the default. - Mercury Voice is enterprise-only through the API, per the docs, and Mercury Decide is a separate endpoint for classification that bills input only.
The three access plans
On top of the per-token prices, Inception sells access in three plans. They change your rate limits and support, not your token price.
| Plan | What you pay | Requests per minute | Input tokens per minute | Output tokens per minute |
|---|---|---|---|---|
| Free | 100M free tokens, one time | 1,000 | 1,000,000 | 100,000 |
| Developer (pay as you go) | Usage-based, rate card above | 3,000 | 3,000,000 | 300,000 |
| Enterprise | Volume-based pricing | Custom | Custom | Custom |
The limits come from Inception's rate limits page. The free credit is a one-time grant shared across all models, not a monthly allowance, according to the FAQ. When it runs low you add a card under billing and carry on at the usage-based rates.
What the 50% launch discount really means
The discount is the most important pricing fact about Mercury 3, and the least specified. Both the models page and the docs say Mercury 3 is "50% off at launch." Neither gives an end date, a token cap or a notice period.
That's unusual for this tier. Google's Gemini pricing page also runs a promo on Gemini 3.8 Flash, but it dates both ends: $0.75 in and $3.75 out through 31 December 2026, then $1.50 and $7.50 from 1 January 2027. With Mercury 3 you know the after-price but not the date, so any budget you build on $0.35 output has a hole in it. Early users noticed:
"I'm going to start using this instead of Haiku/GPT-Luna for tasks that require speed. I'm wondering if it'll still be useful once the discount is lifted?"
Two pieces of good news sit next to that. First, Inception's co-founder told the same thread that the model "runs in our API at reasonable costs," which is his explanation for the launch prices. Another commenter pushed back that pricing "can always be set at a loss," and there's no public data either way.
Second, if you're an existing Mercury customer, the list price is still a small saving. Mercury 2.5 costs $0.20 in and $0.75 out today, so Mercury 3 at its full $0.70 output rate is cheaper than the model it replaces, with nearly four times the context. Mercury 2 users save on input too. Existing customers keep Mercury 2 and 2.5 access until 15 November 2026, so that migration has a deadline even if the discount doesn't.
Mercury 3 vs GPT-6 Luna, Haiku 5.5, DeepSeek and Gemini Flash
Inception positions Mercury 3 against GPT-6 Luna and Claude Haiku 5.5. I added DeepSeek V4.1 Flash, which Hacker News testers compared it to, and Gemini 3.8 Flash as the Google option. Every price below comes from that vendor's own page.
| Model | Input | Cached input | Output | Long-prompt rule | Source |
|---|---|---|---|---|---|
| Mercury 3 (launch) | $0.10 | $0.01 | $0.35 | Flat to 1M | Inception |
| Mercury 3 (list) | $0.20 | $0.02 | $0.70 | Flat to 1M | Inception |
| GPT-6 Luna | $0.10 | $0.01 | $0.50 | Over 272K: 2x input, 1.5x output | OpenAI |
| Claude Haiku 5.5 | $0.10 | $0.01 | $0.50 | Over 100K: $0.50 / $2.50 | Anthropic |
| DeepSeek V4.1 Flash | $0.15 | $0.003 | $0.60 | Flat to 1M; peak hours 2x | DeepSeek |
| Gemini 3.8 Flash | $0.75 | $0.075 | $3.75 | Promo to 31 Dec 2026, then 2x |
Per million tokens, standard tier. DeepSeek's figures are off-peak; peak hours (01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays) cost double.
Read the output column and the story is simple. At launch, Mercury 3 has the cheapest output token in this group. At list, it has the most expensive output of the four budget models, and Gemini 3.8 Flash sits in a higher price class altogether.
Input is a tie with Luna and Haiku at $0.10 during launch, then twice theirs at list. Cached input is where DeepSeek is in a league of its own at $0.003, more than three times cheaper than anyone else's cached rate.
The column most comparisons skip is the long-prompt rule. Haiku 5.5 bills a whole request at $0.50 in and $2.50 out once the prompt passes 100,000 tokens, cache reads included. Luna moves to 2x input and 1.5x output past 272K. Mercury 3 charges the same rate across its full 1M window, which one early tester spotted straight away:
"If these benchmarks hold up it is a no-brainer against Haiku 5.5 and GPT-6 Luna, especially considering that Haiku 5.5 becomes 5x more expensive past 100k context, and this model goes up to 1M for the same price. (Note: the price increases 2x after a period post launch but is still way lower than Haiku is priced for >100k requests)"
My GPT-6 Luna pricing and Haiku 5.5 pricing breakdowns cover those thresholds in detail, and the V4.1 Flash pricing post explains DeepSeek's peak-hour rules.
Mercury 3 cost calculator
Rates per million tokens are hard to feel. Pick a job below, or type your own token counts, and the calculator prices one month on each model at its vendor's standard rate. Flip DeepSeek between off-peak and peak to see how much the clock matters there.
Pick a job or enter your own token counts to compare a month of Mercury 3 at launch and list price with GPT-6 Luna, Claude Haiku 5.5, DeepSeek V4.1 Flash and Gemini 3.8 Flash.
What a real task costs on Mercury 3
Here are the four presets from the calculator as a table, so you can see the pattern without clicking. Each assumes standard rates, DeepSeek off-peak, and no free credits.
| Job (per month) | Shape of one task | Mercury 3 launch | Mercury 3 list | GPT-6 Luna | Haiku 5.5 | DeepSeek V4.1 Flash | Gemini 3.8 Flash |
|---|---|---|---|---|---|---|---|
| 20,000 support replies | 1 call, 6,000 in (70% cached), 400 out | $7.24 | $14.48 | $8.44 | $8.44 | $10.45 | $63.30 |
| 10,000 agent tasks | 12 calls, 8,000 in (85% cached), 600 out | $47.76 | $95.52 | $58.56 | $58.56 | $67.25 | $439.20 |
| 1,000 long documents | 1 call, 200,000 in, 2,000 out | $20.70 | $41.40 | $21.00 | $105.00 | $31.20 | $157.50 |
| 500,000 classifications | 1 call, 1,500 in, 150 out | $101.25 | $202.50 | $112.50 | $112.50 | $157.50 | $843.75 |
Three things jump out.
First, every number is small. Ten thousand 12-step agent tasks cost less than $100 a month on Mercury 3 even at list price. For most teams reading this, the model bill is not the decision. Speed, quality and the work around the model are.
Second, list price changes the ranking. At launch Mercury 3 wins every row. At list it loses to Luna and Haiku 5.5 on support replies, agent tasks and classification, by roughly 1.6x to 1.8x. On long documents it beats Haiku 5.5, whose over-100K rate kicks in ($41.40 against $105), but still costs about twice Luna's $21. Push the prompt past 272K and Luna's long-context rate closes that gap to a tie.
Third, output is most of the bill once caching works. In the agent-task row at list price, here's where the money goes:
With 85% of input cached at a tenth of the price, the 600 output tokens per call outweigh 8,000 input tokens. Since reasoning tokens bill as output, the reasoning effort you pick is the main cost dial. Moving from the default low to medium or high adds thinking tokens to every call. Test whether instant or low holds quality on your job before paying for more.
One more line from that table deserves its own note. If your job is classification, Mercury 3 is the wrong Inception model to price. Mercury Decide bills input only, at $0.02 per million at launch and $0.04 at list, and doesn't charge for output. The same 500,000 classifications would cost about $15 at launch, against $101.25 on Mercury 3. My guide to AI ticket classification covers when a classifier beats a chat model for that job.
The billing details that move your bill
Beyond the rate card, five details change what you actually pay. None of them is hidden, but they're spread across four different pages.
Caching is automatic, with no write fee
Inception caches repeated prompt prefixes on its own, with no request parameter. Cached tokens bill at a tenth of the input price, and the rate card has no cache-write premium. That's simpler than OpenAI's and Anthropic's cards, which both list a separate cache-write rate ($0.125 per million for Luna and Haiku 5.5's 5-minute writes). The trade-off is control: the FAQ says Inception doesn't document how long a prefix stays cached, and you can't pin or inspect entries.
The effect in practice is big. OpenRouter publishes what Mercury 3 callers actually pay, and on 20 October 2026 its weighted average input price was $0.0222 per million, against a listed $0.10, with an 86.6% cache hit rate across its traffic. If your app reuses a long system prompt, budget your input closer to the cached rate than the headline rate.
OpenRouter costs the same
OpenRouter's Mercury 3 page lists one provider, Inception, at the same $0.10 / $0.35 / $0.01 launch prices. So routing through OpenRouter doesn't save or cost you anything on the token rate. Inception also lists Baseten and Vercel as launch partners, but neither publishes a Mercury 3 price; Baseten asks you to contact them. If you already buy open models through Together AI or Fireworks, keep in mind that Mercury 3 has no public weights, so it's only sold by Inception and the partners it names.
The free tokens go further than they sound
100 million tokens is a lot at this size. At the support-reply shape above, about 6,400 tokens per reply, that's roughly 15,600 replies if every token counts against the grant. At the 12-call agent shape, about 103,000 tokens per task, it's under 1,000 tasks. It's enough to run a real evaluation on your own traffic, which is exactly how I'd spend it.
Rate limits can bite before price does
The free tier allows 100,000 output tokens per minute. A single request streaming at Inception's quoted 1,068 tokens per second produces about 64,000 tokens a minute, so two full-speed streams can hit the free tier's output cap. Pay-as-you-go triples that to 300,000. In practice OpenRouter measured a one-week average of 203 tokens per second, so you get more headroom, but if you're planning a parallel agent fleet, check the limits table before the price table.
There's no batch discount
OpenAI and Anthropic both offer half-price batch processing on Luna and Haiku 5.5, and Google has Batch and Flex tiers. Inception's rate card has no batch tier. For overnight jobs where latency doesn't matter, Luna batch at $0.05 in and $0.25 out undercuts even Mercury 3's launch price, so batch-friendly workloads are the one place I'd skip Mercury 3 on cost alone. My OpenAI API pricing guide covers how the batch tier works.
Is the speed worth paying list price for?
This is the real question behind the discount. If Mercury 3 were only cheap, the end of the promo would end the case for it. The case that survives list price is speed.
Inception quotes 1,068 tokens per second; OpenRouter's measured average over a week was 203, against roughly 130 that Inception lists for Luna. The gap matters most in agent loops, where calls run back to back and each second of generation stacks up. My Mercury 3 overview has a calculator for that wait time. For pricing, the useful framing is this: at list, you're paying roughly 1.6x to 1.8x Luna's token bill to cut generation time on long chains. For Claude Code subagents, browser agents and voice pipelines, that's often worth it. For a background job nobody waits on, it isn't.
If speed is the reason you're here, it's also worth comparing the hardware route. Groq sells fast inference on open models, covered in my Groq 3 LPX post. And if you want to understand why diffusion models are fast in the first place, my explainer on diffusion-based AI models walks through it.
When Mercury 3 is the cheap choice, and when it isn't
Here's how I'd decide, with the list price in mind.
- Long prompts, 100K tokens and up. Mercury 3 at list beats Haiku 5.5 outright here. Against Luna it costs about twice as much between 100K and 272K, then roughly ties past 272K. If your calls carry several hundred thousand tokens of documents or history, it's a strong pick at either price.
- Agent loops where speed matters. Pay the premium at list. Re-run the calculator with your real token counts first.
- High-volume, short, latency-tolerant calls. At list, Luna and Haiku 5.5 are cheaper, and DeepSeek V4.1 Flash off-peak is close. Enjoy the launch price while it lasts, but build your budget on the alternatives.
- Batch or overnight jobs. Use a provider with a batch tier. Luna batch is half Luna's standard rate.
- Classification and routing. Price Mercury Decide, not Mercury 3, or a small model. My roundup of small language models covers options you can host yourself.
- Anything needing vision or open weights. Mercury 3 is text only with closed weights. DeepSeek V4.1 Flash supports vision and Gemini 3.8 Flash takes images too. If you want an open diffusion model, look at DiffusionGemma.
If you're comparing more of the budget tier, my Gemini 3.8 Flash pricing, Gemini 3.5 Flash-Lite pricing and Kimi K3 pricing breakdowns use the same per-task method.
The token bill vs the full cost of an AI agent
Most of the cost of putting a model on a real job sits outside the rate card, and support is where I see it most clearly. A 10,000-ticket month is under $100 of Mercury 3 tokens even at list price. But to get those tokens answering tickets, you build the helpdesk connection, retrieval over your help center and past tickets, rules for when to hand off, a way to test against real conversations, and the monitoring to catch a bad answer. That's weeks of engineering, plus upkeep every time your helpdesk or your policies change.
That trade-off is familiar from our own sales calls. An engineering lead at a crypto-hardware company with a 300-plus article Confluence knowledge base put it simply when they chose to buy instead of build:
"We could try to write our own LLM application but we didn't want to invest our time into that. We wanted something that we would not have to maintain."
Look at what one of our customers runs to see the scale. smava, a Berlin loan comparison platform, handles about 27,000 Zendesk tickets a month across two brands with three eesel agents: one categorises every ticket, one drafts the reply from about 820 macros and help center articles, and one per brand prepares customer-ready answers for tickets with no advisor assigned. Agents approve each draft, and a ticket with attachments goes to a person with a note. Every one of those rules is work that a per-token bill doesn't include.
SE Ranking is a different shape of the same point: about 4,650 conversations a month across three products, with one eesel agent per product, answering from roughly 16,800 pages of knowledge. Neither team had to think about tokens, caching or reasoning effort. My guides to AI vs human agent cost and chatbot cost run the full numbers on both routes.
Try eesel
Mercury 3 is infrastructure, and at launch it's very good value infrastructure. eesel is the employee. If you're pricing a model because you want AI answering support tickets, its AI helpdesk teammate joins the queue you already run, on Zendesk and the other major helpdesks, learns from your past tickets and docs, and replays itself against your historical conversations before it answers a single customer.
The pricing works the way a support lead thinks: plans start at $299 a month for 500 credits, a ticket or a chat is one credit however long it runs, and the free trial gives you 100 credits with no card. Compare that with a per-token build on the pricing page.
If you'd rather drive it the way you'd drive a model API, the eesel CLI operates the same teammate from a terminal, and every command returns JSON a script or coding agent like Claude Code can read. My AI agent CLI guide shows what that looks like. Try eesel on last month's tickets and see the cost per answered ticket for yourself. And if you're here because you write content, not tickets, the roster also has an AI blog writer.