MiniMax M2 pricing: what it costs per token, and how to access it

Quick answer: what MiniMax M2 costs right now

MiniMax M2 is the flagship large language model line from MiniMax, one of China's better known frontier AI labs. The current shipping generation on this catalog is MiniMax-M2.7, billed the way almost every hosted LLM is billed: a per-token rate for what you send in, and a separate, higher per-token rate for what the model writes back. At $0.27 per million input tokens and $1.08 per million output tokens, MiniMax-M2.7 sits well below flagship Western models and close to the cheapest Chinese-developed models available anywhere. MiniMax's own published rate for the same model is $0.30 input and $1.20 output. A single short exchange, a few hundred tokens in and a few hundred back, costs a fraction of a cent either way. The number that actually moves month to month is volume, not the per-token rate, which is what the rest of this page works through.

How MiniMax prices M2, and what the official rate does not include

MiniMax bills the way most hosted model providers do: input and output tokens are metered separately, with output priced several times higher than input because generation is the expensive half of a forward pass. That structure is not unique to MiniMax, it is close to identical to how OpenAI, Anthropic, and every Chinese lab in this catalog price their models. Only the per-token numbers differ. What the official list price does not show is how you actually reach it. MiniMax's direct API has historically leaned on mainland Chinese identity verification and domestic payment rails, and its documentation is written primarily for a Chinese-speaking developer audience. None of that shows up on a pricing page, but it is real friction if you are calling the API from outside China with a foreign card and no local phone number. One more wrinkle is worth flagging even though it cannot be confirmed from a pricing table alone: some reasoning-style models bill an internal thinking pass as extra output tokens before the visible reply appears. Whether MiniMax-M2.7's reasoning mode does this is worth checking against current MiniMax documentation before budgeting a workload that leans on it, since it changes the output side of the math below.

Worked example: three volumes, two rates

Token counts are the only thing that scales with your usage, the per-token rate stays fixed. The table below prices three workload sizes at both the catalog rate used on this page and MiniMax's own published rate, so the gap is visible in dollars rather than percentages.

Why the bill surprises people who only read the price page

None of this makes MiniMax-M2.7 expensive. It makes the sticker price a lower bound rather than a guarantee, which is true of most token-metered APIs and just more visible here because the headline number is unusually low.

• Getting an account is its own project. MiniMax's direct signup has typically wanted a mainland Chinese phone number and domestic payment methods, so the published rate is only reachable once onboarding clears, not the moment you read the pricing page.
• The docs assume a Chinese-speaking developer. Parameter names, error codes, and rate-limit tables are written primarily in Mandarin, so a wrong assumption about a field costs a support cycle, not just tokens.
• A 1M-token window invites overuse. It is easy to paste an entire document, ticket history, or codebase into one call because the window allows it, and every one of those tokens bills as input whether the model needed all of them or not.
• Chat history compounds. Like most chat completions APIs, the full conversation is resent on every turn, so a twenty-message thread bills its entire history twenty times over across the conversation, not once at the end.
• Published rate and invoiced rate are not always the same number. Minimum top-up amounts, currency conversion, and promotional windows can all move what you actually pay away from what the pricing page states.

MiniMax-M2.7 against the rest of the catalog

MiniMax-M2.7's position is clearest next to other models billed the same way. It undercuts flagship Western reasoning models by a wide margin, and it sits close to the cheapest Chinese-developed budget models rather than standing alone at the bottom of the table.

Keeping the actual bill close to the sticker price

The model choice rarely needs to change once it works. The checks above just keep a stale assumption from becoming next month's invoice.

• Pin the exact model ID before committing spend. MiniMax M2 is a family name; MiniMax-M2.7 is the ID that gets billed today, and an ID copied from an old post can 404 or quietly resolve to a different tier.
• Treat the 1M-token window as a ceiling, not a target. Scope a prompt to the section of a document or the part of a repo the task actually needs instead of pasting everything just because the window allows it.
• Cap or summarize chat history in long-running sessions. Every prior turn rides along as input on the next call, so an unbounded conversation bills its own past on every message.
• Compare the official rate to what a gateway carries the same model ID for. APIsRouter prices Chinese-developed models like this one below their own official rate, so the same model ID and the same request shape can land on a lower number than MiniMax's direct list price.
• Smoke-test with a single small request before wiring a new model ID into a production loop, so a typo in the model name or an auth header fails on one cheap call instead of partway through a batch job.

Calling MiniMax-M2.7 through an OpenAI-compatible endpoint

MiniMax-M2.7 sits behind the same OpenAI-compatible chat completions shape as every other model on this catalog, so pointing an existing OpenAI SDK setup at it is a base_url and a model string, not a new client library or a separate account. Pay-as-you-go billing means there is no signup form ahead of it either: checkout happens first, and the key arrives by email. Verify the key and the model ID with a small request before wiring anything into a longer pipeline:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.apisrouter.com/v1",
    api_key="sk-APIsRouter-...",
)

response = client.chat.completions.create(
    model="MiniMax-M2.7",
    messages=[
        {
            "role": "user",
            "content": "Summarize the tradeoffs between transformer and state-space model architectures in three sentences.",
        }
    ],
)

print(response.choices[0].message.content)

FAQ