Read time: ~12 minutes.

Key facts:

• Inception released Mercury 3 on October 19, 2026. It is a diffusion LLM: it refines many tokens in parallel instead of writing one token at a time. Inception reports 1,068 tokens per second on NVIDIA GPUs and says it matches or beats GPT-6 Luna and Claude Haiku 5.5 on its benchmarks (Inception blog).
• Model ID mercury-3, endpoint https://api.inceptionlabs.ai/v1/chat/completions, OpenAI-compatible. 1M-token context, up to 131,072 output tokens, text in and text out only (Inception models page).
• Price: $0.20 input / $0.70 output per 1M tokens, 50% off at launch ($0.10 / $0.35). Cached input is 90% off the input price. New accounts get 100 million free tokens, no card needed (Quick Start).
• reasoning_effort takes instant, low, medium, high. Temperature is limited to 0.5–1.0. There is no seed and no embeddings endpoint.
• Also available as inception/mercury-3 on OpenRouter, plus Baseten and Vercel, and as a built-in provider in OpenCode.

What we checked: we installed the official inceptionai Python SDK (version 0.2.0, published October 18, 2026) in a fresh virtualenv and confirmed its chat.completions.create() accepts reasoning_effort, diffusing, realtime, reasoning_summary, response_format, tools and tool_choice. We confirmed the public /v1/models endpoint and OpenRouter’s model list both show Mercury 3, and that an unauthenticated request returns the invalid_api_key error documented below. We did not run paid generations, so every speed and quality number here is Inception’s, not ours.

Most “fast” models are small autoregressive models: they’re quick because they’re cheap, and you give up quality for it. Mercury 3 takes a different route. It’s a diffusion language model, so it drafts a whole block of text and refines it over a few passes rather than emitting tokens one by one. Inception’s pitch is that this gets you speed-tier latency with mid-tier quality, which matters most for agents, where every step waits on the model and small delays add up.

This guide gets you from zero to a working Mercury 3 integration: first request, the settings that actually change behavior, streaming, tool calling, structured output, the third-party routes (OpenRouter, LiteLLM, OpenCode, Claude Code), and the errors and limits you’ll run into. If you’re comparing it against OpenAI’s budget tier, our GPT-6 family switching guide has the gpt-6-luna model ID and prices. More builder guides are on the 7minai homepage.

---

1. What Mercury 3 is and when to use it

From Inception’s launch post and models page:

	Mercury 3
Model ID	mercury-3
Endpoint	v1/chat/completions
Context window	1M tokens (Mercury 2.5 was 260K)
Max output	131,072 tokens
Input / output	Text only (no images, no image generation)
Features	Tool calling (including parallel calls), structured outputs, streaming
Reasoning effort	instant, low, medium, high
Temperature	0.5 to 1.0
Price per 1M tokens	$0.20 in / $0.02 cached in / $0.70 out; launch price $0.10 / $0.01 / $0.35
Speed (Inception’s figure)	1,068 tokens/s on NVIDIA GPUs

Inception says Mercury 3 is more than 40x larger than Mercury 1 in total parameters, and positions it against speed-optimized frontier models (it names GPT-6 Luna and Claude Haiku 5.5), not against flagship models.

Good fits, per the use cases Inception and its early-access partners describe:

• Agent loops where the model is called many times per task: browser agents, search agents, log triage. TinyFish AI, quoted in the launch post, says Mercury 3 completed 50% of 50 live Mind2Web navigation tasks in its web-agent harness, using the same token volume and step count as a frontier model.
• Interactive tutoring and support, where a second of delay is noticeable. Octen AI reports a median generation time of 0.9 seconds and a median end-to-end response of 2.2 seconds in its search tests.
• High-volume automations where instant effort and low per-token cost matter more than peak reasoning.

Poor fits: anything that needs image input, embeddings (there is no /v1/embeddings), fine-tuning (not offered through the public API), or bit-exact reproducibility (no seed parameter). Those come straight from Inception’s FAQ.

Those partner numbers are their own tests, not independent benchmarks. Run your own eval on your workload before you switch production traffic.

---

2. Get an API key

1. Create an account at the Inception Platform. Every new account gets a one-time credit of 100 million free tokens, shared across all Mercury models, with no payment details required.
2. Open API Keys in the dashboard (direct link) and create a key.
3. Export it. The official SDKs read INCEPTION_API_KEY automatically.

# macOS / Linux
export INCEPTION_API_KEY="your_api_key_here"

# Windows PowerShell
$env:INCEPTION_API_KEY="your_api_key_here"

Keep the key server-side. Inception’s authentication page warns against putting it in client-side code or committing it to git, and that applies doubly to a model this cheap: a leaked key can burn through a lot of tokens very quickly.

When the free credit runs low, add a payment method under Billing in the same dashboard.

---

3. Send your first request

With curl

This is the request from Inception’s Quick Start:

curl https://api.inceptionlabs.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $INCEPTION_API_KEY" \
  -d '{
    "model": "mercury-3",
    "messages": [
      {"role": "user", "content": "What is a diffusion model?"}
    ],
    "reasoning_effort": "medium",
    "temperature": 0.75,
    "max_completion_tokens": 8192
  }'

With the official Python SDK

pip install inceptionai

from inceptionai import Inception

client = Inception()  # reads INCEPTION_API_KEY from the environment

completion = client.chat.completions.create(
    model="mercury-3",
    messages=[{"role": "user", "content": "What is a diffusion model?"}],
    reasoning_effort="medium",
    temperature=0.75,
    max_completion_tokens=8192,
)
print(completion.choices[0].message.content)

The PyPI package requires Python 3.9 or later. There’s also a TypeScript package with the same name (npm install inceptionai) and the same method shape: new Inception() then client.chat.completions.create({...}).

With the OpenAI SDK you already use

Because the API is OpenAI-compatible, you can skip the new dependency and point the OpenAI client at Inception’s base URL:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["INCEPTION_API_KEY"],
    base_url="https://api.inceptionlabs.ai/v1",
)

response = client.chat.completions.create(
    model="mercury-3",
    messages=[{"role": "user", "content": "What is a diffusion model?"}],
    max_completion_tokens=8192,
)
print(response.choices[0].message.content)

One caveat: diffusing and realtime aren’t OpenAI parameters, and instant isn’t one of OpenAI’s reasoning_effort values. If you need them through the OpenAI client, pass them in extra_body, or use the inceptionai SDK, which exposes them directly.

With the Vercel AI SDK

Inception’s docs show the generic OpenAI-compatible provider:

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

const provider = createOpenAICompatible({
  name: 'inception',
  apiKey: process.env.INCEPTION_API_KEY,
  baseURL: 'https://api.inceptionlabs.ai/v1',
});

const { text } = await generateText({
  model: provider('mercury-3'),
  prompt: 'What is a diffusion model?',
});

---

4. Pick a reasoning effort and token budget

reasoning_effort is the main lever for trading latency against quality. From the Reasoning Efforts page:

Value	Latency	Best for
instant	Lowest	Voice, realtime turns, high-volume automations
low	Low	Latency-sensitive chat and tool calling
medium	Balanced	General-purpose use
high	Highest	Complex, multi-step reasoning

The effort level also changes the default output budget when you don’t set one. According to the chat completions reference, Mercury 3 defaults to 24,576 completion tokens, but 8,192 at instant, 65,536 at medium and 131,072 at high. That budget includes reasoning tokens.

Two practical rules:

1. Always set reasoning_effort explicitly. The reasoning guide says Mercury 3 defaults to low, while the API schema lists medium as the default. Don’t depend on either; name the level you want.
2. Always set max_completion_tokens at high effort. A 131,072-token default is a lot of room for a runaway answer, and reasoning tokens are billed at the output rate. Use max_completion_tokens rather than max_tokens, which is deprecated; when both are sent, max_completion_tokens wins.

Temperature: keep it between 0.5 and 1.0. Values outside that range aren’t rejected. They’re silently reset to the model’s default (1 for Mercury 3, per the API reference) and the response carries a warning field. If your existing code sends temperature: 0 for “deterministic” output, it will quietly run at 1 instead. Check for that warning in your logs after you switch.

There’s also a realtime boolean, documented as a flag “for more realtime workloads that require lower TTFT/TTFAT” (time to first token, and time to first answer token). It’s aimed at voice-style workloads. Test it against your own latency numbers rather than turning it on by default.

---

5. Stream the answer, or watch it diffuse

Streaming works like OpenAI’s, with one difference: Mercury emits blocks of refined text rather than single tokens (Streaming & Diffusion docs).

from inceptionai import Inception

client = Inception()

stream = client.chat.completions.create(
    model="mercury-3",
    messages=[{"role": "user", "content": "What is a diffusion model?"}],
    max_completion_tokens=1000,
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="", flush=True)

Set diffusing: true as well and the stream shows the model’s intermediate denoising steps. The important detail: in diffusing mode each chunk is the full text so far, not a delta. If you append chunks the way you would for normal streaming, you’ll print the answer many times over. Replace the displayed text on every chunk instead:

stream = client.chat.completions.create(
    model="mercury-3",
    messages=[{"role": "user", "content": "What is a diffusion model?"}],
    max_completion_tokens=1000,
    stream=True,
    diffusing=True,
)
for chunk in stream:
    # Each chunk is the whole text at this denoising step
    print(chunk.choices[0].delta.content or "", flush=True)

In a browser you’d set element.textContent = chunk on each event rather than +=. Diffusing mode is a demo and UX feature; for production chat, plain stream: true is what you want.

To get token counts from a stream, add stream_options: {"include_usage": true}. You’ll receive a final usage chunk before data: [DONE] (FAQ).

---

6. Call tools

Mercury 3 uses the standard OpenAI tool-calling shape, including parallel tool calls (Tool Use docs). Here’s the full round trip, adapted from Inception’s example:

import json
from inceptionai import Inception

client = Inception()

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City and state, e.g. 'San Francisco, CA'"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
            },
            "required": ["location", "unit"],
        },
    },
}]

def get_weather(location: str, unit: str) -> str:
    # Replace with your real API call
    return json.dumps({"location": location, "unit": unit, "temperature": 18})

messages = [{"role": "user", "content": "What's the weather like in San Francisco?"}]

# 1. The model asks for a tool call
completion = client.chat.completions.create(model="mercury-3", messages=messages, tools=tools)
message = completion.choices[0].message
tool_call = message.tool_calls[0]
args = json.loads(tool_call.function.arguments)

# 2. Run the tool and send the result back, matched by tool_call_id
messages.append(message.model_dump(exclude_none=True))
messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": get_weather(**args)})

# 3. The model writes the final answer
final = client.chat.completions.create(model="mercury-3", messages=messages, tools=tools)
print(final.choices[0].message.content)

For an agent, put steps 1 to 3 in a loop until the model stops returning tool_calls.

Parallel calls: when a question needs several independent lookups (“weather in San Francisco and New York”), Mercury 3 can return multiple tool_calls in one response. Run them concurrently (Inception’s example uses ThreadPoolExecutor), then append one tool message per call before the next request. If a later call depends on an earlier result, run them in sequence.

Controlling tool use:

• tool_choice: "auto" (default when tools are present) lets the model decide.
• "required" forces a tool call this turn; "none" prevents one.
• {"type": "function", "function": {"name": "get_weather"}} forces a specific tool.
• Inception recommends adding "strict": true to each tool definition so arguments match your schema.

This is where Mercury’s speed pays off most. An agent that makes 20 model calls per task feels very different at sub-second turns. If you’re building browser automation, our Browser Use tutorial shows the agent side; any framework that accepts an OpenAI-compatible base URL can be pointed at Mercury.

---

7. Force structured JSON output

Pass a JSON Schema in response_format (Structured Outputs docs):

response_schema = {
    "name": "Sentiment",
    "strict": True,
    "schema": {
        "type": "object",
        "properties": {
            "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
            "confidence": {"type": "number", "minimum": 0, "maximum": 1},
            "key_phrases": {"type": "array", "items": {"type": "string"}},
        },
        "required": ["sentiment", "confidence", "key_phrases"],
    },
}

completion = client.chat.completions.create(
    model="mercury-3",
    messages=[{"role": "user", "content": "Analyze the sentiment of: 'I love this feature, it saves me so much time.'"}],
    response_format={"type": "json_schema", "json_schema": response_schema},
)
data = json.loads(completion.choices[0].message.content)

The API also accepts a plain JSON object mode ({"type": "json_object"}), but a strict schema is what you want when another program parses the result.

---

8. Use Mercury 3 without the Inception API

You don’t have to integrate Inception’s API directly. The launch post lists OpenRouter, Baseten and Vercel as launch partners, and Inception’s docs include several tool integrations.

OpenRouter

OpenRouter lists the model as inception/mercury-3 with a 1,000,000-token context, a 131,072-token max output, and the launch price ($0.10 in, $0.35 out per 1M). Inception is the serving provider. Use your OpenRouter key and base URL:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENROUTER_API_KEY"], base_url="https://openrouter.ai/api/v1")

r = client.chat.completions.create(
    model="inception/mercury-3",
    messages=[{"role": "user", "content": "Summarize what a diffusion LLM is in two sentences."}],
    max_tokens=500,
)
print(r.choices[0].message.content)

OpenRouter’s listing shows support for reasoning_effort, tools, tool_choice, response_format, structured_outputs, temperature, stop and max_tokens. Inception-only extras such as diffusing aren’t on that list, so use the direct API if you need them.

LiteLLM

Inception’s Quick Start says Inception is a native LiteLLM provider, which reads INCEPTION_API_KEY from the environment:

from litellm import completion

response = completion(
    model="inception/mercury-3",
    messages=[{"role": "user", "content": "What is a diffusion model?"}],
    max_tokens=8192,
)
print(response.choices[0].message.content)

OpenCode

OpenCode has Inception as a built-in provider (Inception’s OpenCode guide): run opencode, type /connect, search for Inception, choose Add account, paste your key, and select Mercury 3. Switch models later with /models.

Claude Code (unofficial bridge)

Inception documents a mercury-cc launcher that runs Claude Code against Mercury 3 through a local LiteLLM proxy (Inception’s Claude Code guide). It needs macOS or Linux and Python 3.11+, installs litellm[proxy]==1.99.0 in its own virtualenv, and sets ANTHROPIC_BASE_URL plus the model-alias variables only inside the launcher, so your normal claude command is untouched. Inception’s own warning is worth repeating: Anthropic does not support routing Claude Code to non-Claude models, and LiteLLM is a third-party component sitting between your code and the API. Follow the guide exactly if you try it, and don’t use it on sensitive repositories without reviewing the proxy first. If you do run Claude Code this way, our Claude Code permissions guide still applies, since the permission rules live in Claude Code, not the model.

---

9. Work out what it will cost

Responses include a usage object (FAQ):

• prompt_tokens: all input, including cached input
• prompt_tokens_details.cached_tokens: the cached subset
• completion_tokens: all output, including reasoning tokens
• completion_tokens_details.reasoning_tokens: the reasoning subset
• total_tokens

The detail counts are already inside their parent totals, so don’t add them twice. There’s no dollar field, so compute it yourself. At the launch price:

def mercury3_cost(usage, launch=True):
    inp, cached_rate, out = (0.10, 0.01, 0.35) if launch else (0.20, 0.02, 0.70)
    details = usage.prompt_tokens_details
    cached = (details.cached_tokens if details else 0) or 0
    uncached = usage.prompt_tokens - cached
    return (uncached * inp + cached * cached_rate + usage.completion_tokens * out) / 1_000_000

Worked example: a request with 2,000 uncached input tokens and 500 output tokens costs (2,000 × $0.10 + 500 × $0.35) / 1,000,000 = $0.000375 at the launch price, or about $0.38 per thousand such requests. At the regular price, double it.

Prefix caching is automatic. You don’t send a parameter, and cached tokens show up in cached_tokens. Inception doesn’t document how long a cached prefix lives, so keep long system prompts stable and at the start of your messages to give the cache the best chance.

---

10. Rate limits

Per-minute limits from the Rate Limits page:

	Free	Pay as you go	Enterprise
Requests	1,000	3,000	Custom
Input tokens	1,000,000	3,000,000	Custom
Output tokens	100,000	300,000	Custom

The output-token limit is the one you’ll hit first on a fast model. At Inception’s quoted ~1,000 tokens per second, a few concurrent high-effort requests with large completion budgets can use up the free tier’s 100,000 output tokens per minute. Cap max_completion_tokens, and contact support if you need more.

---

11. Troubleshooting

Error codes from Inception’s error reference, with the fixes that apply:

Status	What it means	Fix
400	Invalid request; context_length_exceeded means you went over 1M tokens	Trim messages or lower the completion budget
401	Bad key ("code": "invalid_api_key")	Send Authorization: Bearer $INCEPTION_API_KEY; regenerate the key if needed
402	Billing inactive or quota exceeded (Account is inactive)	Add payment info under Billing
404	Model not found	Check the ID: it’s mercury-3 on Inception’s API and inception/mercury-3 on OpenRouter
429	Rate limit	Exponential backoff; lower concurrency or completion budgets
500 / 502 / 503	Server, upstream or engine overload	Wait briefly and retry; contact support if it persists

Problems that don’t show up as errors:

• Output feels more random than expected. You probably sent a temperature outside 0.5–1.0 and it was reset to 1. Look for the warning field in the response.
• Streaming prints the answer over and over. You turned on diffusing. Each chunk is the full text, so replace instead of appending.
• Your typed client won’t accept reasoning_effort: "instant" or diffusing. OpenAI’s SDK types don’t include them (TypeScript will flag them at compile time). Send them through extra_body, or use the inceptionai SDK.
• The MCP or agent framework you’re using asks for a model name. Inception’s FAQ answer on MCP clients still says mercury-2.5; use mercury-3 if you want the new model.
• Image input fails. Mercury 3 is text-only. Only Mercury Decide accepts images.

---

FAQ

Can I download the weights? Inception hasn’t announced downloadable weights. Mercury 3 is served through Inception’s API and its partners (OpenRouter, Baseten, Vercel), and Inception offers enterprise deployments with dedicated capacity, autoscaling and configurable data retention.

Can I get reproducible outputs? Not bit-for-bit. There’s no seed, and temperature can’t go below 0.5. Inception suggests averaging over several samples for evaluation.

Does it do embeddings or fine-tuning? No embeddings endpoint, and no self-serve fine-tuning. Pair it with a separate embeddings provider for RAG.

How does it compare with Gemini Flash or GPT-6 Luna? Inception claims Mercury 3 matches or beats GPT-6 Luna and Claude Haiku 5.5 while running 4–8x faster, but those are vendor benchmarks. Run the same eval set through each. Our Gemini 3.6 Flash guide and GPT-6 switching guide have the setup for the main alternatives.

How long does the launch discount last? Inception’s pages say “50% off at launch” without an end date. Budget with the regular $0.20 / $0.70 price so the discount ending doesn’t surprise you.

---

Sources

• Diffusion at Scale: Introducing Mercury 3, Inception, October 19, 2026
• Inception Platform docs: Quick Start, Models, Reasoning Efforts, Streaming, Tool Use, Structured Outputs, Rate Limits, Error Codes, FAQ
• Inception Claude Code integration and OpenCode integration
• OpenRouter: Inception Mercury 3
• inceptionai on PyPI