Mercury 3 vs Mercury 2.5 Preview vs Mercury 2

Short answer: Mercury 3 for long context and long output, Mercury 2.5 Preview for per-token price

LLMTR is a gateway that gives access to language models from different providers through one OpenAI-compatible API. Inception Labs' three Mercury models, Mercury 3 (inception/mercury-3), Mercury 2.5 Preview (inception/mercury-2.5-preview) and Mercury 2 (inception/mercury-2), are called here on the /v1/chat/completions endpoint at https://llmtr.com/v1 with the same API key from your llmtr.com account. All three are diffusion-based language models: instead of writing tokens strictly one after another, they produce several in parallel and refine them step by step. All three accept text only and support tool calling and JSON output that follows a schema.

Two things decide the choice: the length of the prompt and the answer, and the per-token price. Mercury 3 has a 1,000,000-token context window and a 131,072-token limit per response; on Mercury 2.5 Preview those figures are 260,000 and 65,536, and on Mercury 2 they are 128,000 and 50,000. On per-token price the order reverses: Mercury 2.5 Preview, at $0.04 input and $0.15 output per 1M tokens, is below the other two. Mercury 3 costs $0.10 input and $0.35 output at its introductory price through the end of 25 October 2026 (TRT), and $0.20 and $0.70 from 26 October 2026. Mercury 2, at $0.25 and $0.75, is above both of Mercury 3's rates.

• Inception, model comparison and pricing · 2026-10-19
• Inception, Introducing Mercury 3 · 2026-10-19

Which Mercury model id should you use on LLMTR?

If you are building a new integration and your prompts can pass 260,000 tokens, or you need more than 65,536 tokens of output in one response, the option is Mercury 3. If per-token price matters most for short, high-volume requests, try Mercury 2.5 Preview on your own examples; this row is a preview release and the provider may change its behaviour and its price. For an integration that uses Mercury 2, Mercury 3 costs less on input and output even at its standard rate and has a larger window and output limit; moving is a change of the model string.

The table shows the three rows with the values in the LLMTR catalog; prices are per 1M tokens, in the order input / cached input / output.

What does the same request cost on each model?

Without a cache hit, and assuming the same token counts on all three models, a 20,000-token prompt with a 2,000-token answer costs $0.0027 on Mercury 3 at the introductory price, $0.0054 from 26 October 2026, $0.0011 on Mercury 2.5 Preview and $0.0065 on Mercury 2. If 15,000 tokens of the prompt are read from the cache on Mercury 3, the same request costs $0.00135 at the introductory price and $0.0027 at the standard rate; cached input is a tenth of the input price.

Read this calculation with one limit in mind: all three models reason by default, reasoning tokens are billed at the output price, and the number of reasoning tokens for the same question differs from model to model. To see the real cost, send the same prompt to all three. The Python example below sends a support ticket to the three models with reasoning_effort: minimal, reads the token counts and the cached input in usage, and works out the cost; it picks Mercury 3's price by the day it runs.

OpenAI Python SDK example that sends the same prompt to the three Mercury models through https://llmtr.com/v1/chat/completions and prints token usage and cost.

import os
from datetime import datetime, timezone

from openai import OpenAI

client = OpenAI(base_url="https://llmtr.com/v1", api_key=os.environ["LLMTR_API_KEY"])

# Per 1M tokens: (input, cached input, output).
# Mercury 3: introductory price through 25 October 2026 (TRT), standard rate from 26 October.
INTRO_ENDS = datetime(2026, 10, 25, 21, 0, tzinfo=timezone.utc)
MERCURY_3 = (0.10, 0.01, 0.35) if datetime.now(timezone.utc) < INTRO_ENDS else (0.20, 0.02, 0.70)
PRICES = {
    "inception/mercury-3": MERCURY_3,
    "inception/mercury-2.5-preview": (0.04, 0.004, 0.15),
    "inception/mercury-2": (0.25, 0.025, 0.75),
}
with open("ticket.txt", encoding="utf-8") as f:
    ticket = f.read()
messages = [{"role": "user", "content": "Summarize this support ticket in three bullet points:\n\n" + ticket}]

for model, (inp, cached, out) in PRICES.items():
    response = client.chat.completions.create(
        model=model, messages=messages, max_tokens=4096, reasoning_effort="minimal"
    )
    usage = response.usage
    details = usage.prompt_tokens_details
    hit = (details.cached_tokens or 0) if details else 0
    cost = ((usage.prompt_tokens - hit) * inp + hit * cached + usage.completion_tokens * out) / 1_000_000
    print(model, usage.prompt_tokens, hit, usage.completion_tokens, f"${cost:.6f}")

Which one when?

Each point rests on a value in the LLMTR catalog; compare answer quality on your own examples.

• A prompt over 260,000 tokens, such as a long contract or a large codebase: inception/mercury-3. Its window is 1,000,000 tokens; the other two Mercury rows have 260,000 and 128,000.
• A long output in one response: inception/mercury-3, with a 131,072-token limit. The limit is 65,536 tokens on Mercury 2.5 Preview and 50,000 on Mercury 2.
• Per-token price on short, high-volume requests: inception/mercury-2.5-preview, at $0.04 input and $0.15 output. As it is a preview release, keep a second model id ready in production.
• Turning reasoning off completely: inception/mercury-2.5-preview with reasoning_effort: none. Mercury 3 and Mercury 2 have no none; send minimal.
• If you use inception/mercury-2 today: inception/mercury-3. Its standard rate of $0.20 input and $0.70 output is below Mercury 2's $0.25 and $0.75; the level names are the same, only the default is low instead of medium.

Reasoning levels, suffixes and moving off the retired row

The reasoning level is chosen with the reasoning_effort field or with a suffix on the model id: inception/mercury-3:minimal and reasoning_effort: minimal produce the same request. Mercury 3 and Mercury 2 accept minimal, low, medium and high; Mercury 2.5 Preview accepts none, minimal and medium. A level a model does not list returns 400, and the error message lists the levels that model accepts. When the field is omitted Mercury 3 runs at low and the other two at medium; review this field as well when you change models.

Reasoning tokens also count toward the output limit. A small max_tokens value can make the response end during reasoning; treat a response with finish_reason: length as incomplete and raise max_tokens or choose a lighter level.

The free row inception/mercury-2-free retired on 8 September 2026. Requests to that id return 410, and the response suggests inception/mercury-3; moving is a change of the model string, and requests are billed to your balance.

• Inception, reasoning efforts · 2026-10-19

Trying the three models with the same key

Open an account on llmtr.com, top up your balance under Dashboard > Billing and create a key under Dashboard > API Keys. Set the base URL in your OpenAI-compatible SDK to https://llmtr.com/v1. The same key works on all three models, you do not need a separate account with Inception, and each request is charged to your balance at the catalog price in force when it is processed; on Mercury 3 the standard rate applies on its own from 26 October 2026.

Make the choice with an evaluation set from your own work: look at the length distribution of your prompts, work out the share of requests that pass 128,000 and 260,000 tokens, and put the three models' answers side by side with the token counts in usage. Setting a spending limit on your API key caps the cost during the trial.

Comparing the three Mercury models with the same prompt

Send the same prompt to the three Mercury models with one LLMTR key, compare token counts and cost, and choose by what you need.

1. Key. Top up your balance on llmtr.com and create a key under Dashboard > API Keys.
2. Same prompt. Send your own evaluation set with the three model ids to the https://llmtr.com/v1/chat/completions endpoint.
3. Choice. Compare the answers, token counts and cost, then choose the model id.

Frequently asked questions

How much do the three Mercury models cost?

Per 1M tokens, input / cached input / output: Mercury 3 through 25 October 2026 $0.10 / $0.01 / $0.35, from 26 October 2026 $0.20 / $0.02 / $0.70; Mercury 2.5 Preview $0.04 / $0.004 / $0.15; Mercury 2 $0.25 / $0.025 / $0.75.

What changes when you move from Mercury 2 to Mercury 3?

The model id changes from inception/mercury-2 to inception/mercury-3. The level names are the same; when the field is omitted Mercury 3 runs at low and Mercury 2 at medium. The window grows from 128,000 to 1,000,000 tokens and the output limit from 50,000 to 131,072 tokens.

Does inception/mercury-2-free still work?

No. The free row inception/mercury-2-free retired on 8 September 2026; requests return 410 and the response suggests inception/mercury-3.

Related posts

• Mercury 3 vs Claude Haiku 5.5, GPT-6 Luna, Gemini 3.8 Flash
• MiniMax M3.1 Flash vs Haiku 5.5, GPT-6 Luna, Gemini 3.8 Flash

• Mercury 3 model
• Mercury 2.5 Preview model
• Mercury 2 model
• Reasoning effort documentation
• Tool calling documentation