MiniMax M2 Pricing: Check the Missing ID and Measure Two Current Routes
The exact MiniMax M2 ID was absent from the tested catalog. Separate M2.5 and M2.7 requests passed a strict JSON fixture and produced rate-based estimates without presenting those figures as M2 prices.

This gateway check did not find MiniMax-M2 under the tested credential. It found and separately tested MiniMax-M2.5 and MiniMax-M2.7, so the measured outputs and estimated costs belong only to those newer route names.
Crazyrouter was the gateway for 2 recorded requests in this narrow test; 2 satisfied the predefined full-output rule, and the table retains the unsuccessful attempts.
By Boluo Z · Tested November 4, 2026
What does a current MiniMax M2 pricing check actually show?#
The script looks up three exact identifiers in /v1/models, then reads pricing rows for the same identifiers. The M2 row was not available as a current quote in this check. The two later versions have separate default-group rate fields and cache ratios. MiniMax’s own pricing page covers its native service; it is not a substitute for this gateway’s account rate.
November 4 test setup and observations#
The complete Python 3.10 script ran on Windows with a gateway credential held in the process environment. The request bodies, endpoints, response IDs, terminal states and failures are reproduced below. Script exit code zero means observations were saved; it does not turn an unsuccessful model response into a pass.
| Requested exact model ID | Visible to credential |
|---|---|
| MiniMax-M2 | No; no call under this name |
| MiniMax-M2.5 | Yes |
| MiniMax-M2.7 | Yes |
| Model | Default-group input USD / 1M | Cached input USD / 1M | Output USD / 1M |
|---|---|---|---|
| MiniMax-M2.5 | 0.30 | 0.30 | 1.20 |
| MiniMax-M2.7 | 0.30 | 0.060 | 1.20 |
| Route / fixture | HTTP / error | Terminal state | Accepted | Output or error | Response ID | Usage | USD estimate |
|---|---|---|---|---|---|---|---|
| MiniMax-M2.5 / empty queue | 200 | stop | Yes | {"pending":0} | 00d4b8b8-af88-40bc-8f25-849f99dd777b | {prompt_tokens: 208, completion_tokens: 14, total_tokens: 222, prompt_tokens_details: {cached_tokens: 186}, completion_tokens_details: {reasoning_tokens: 6}} | 0.0000792 |
| MiniMax-M2.7 / empty queue | 200 | stop | Yes | {"pending":0} | c054e7f8-3ddf-4a79-bbac-3a459a41749f | {prompt_tokens: 208, completion_tokens: 17, total_tokens: 225, prompt_tokens_details: {cached_tokens: 58}, completion_tokens_details: {reasoning_tokens: 8}} | 0.00006888 |
| Executed local check | Result |
|---|---|
| uncached | Passed |
| cached subset | Passed |
| reasoning not added twice | Passed |
| native disjoint counters | Passed |
| boolean rejected | Passed |
| cache overflow rejected | Passed |
| inconsistent total rejected | Passed |
| reasoning overflow rejected | Passed |

Two tiny requests, two accepted objects#
Each available route was given the same empty-queue fixture and returned parseable {"pending":0} after whitespace. Both completed with stop. The M2.5 usage yielded an estimated USD 0.0000792; M2.7 yielded USD 0.00006888 under the inspected gateway rows. The latter reported cached input; this is a single observed counter, not proof of reliable caching on repeated real workloads.
Do not infer a quality or savings ranking#
This fixture checks only a tiny JSON object. It does not compare coding skill, context size, rate stability or the native MiniMax account. Price changes, account groups and token accounting can alter a later estimate. The article replaces the older broad access claims with exact IDs, recorded outcomes and an explicit missing-ID gate.
Reproduce this check#
Install requests, set CRAZYROUTER_API_KEY for an authorized account, and run this complete script with Python 3.10 or later. It may generate billable traffic. The script does not print authorization headers.
import json
import os
import time
from decimal import Decimal as D
import requests
BASE = "https://api.crazyrouter.com/v1"
def client():
s = requests.Session()
s.trust_env = False
return s
def catalog(wanted):
with client() as s:
r = s.get(BASE + "/models", headers={"Authorization": "Bearer " + os.environ["CRAZYROUTER_API_KEY"]}, timeout=(10, 40), allow_redirects=False)
r.raise_for_status()
names = {x["id"] for x in r.json()["data"]}
return {name: name in names for name in wanted}
def request(model, prompt, mode="chat", **options):
path = {"chat": "/chat/completions", "messages": "/messages", "responses": "/responses"}[mode]
payload = {"model": model, **options}
if mode == "responses":
payload["input"] = prompt
else:
payload["messages"] = [{"role": "user", "content": prompt}]
headers = {"Authorization": "Bearer " + os.environ["CRAZYROUTER_API_KEY"]}
if mode == "messages":
headers = {"x-api-key": os.environ["CRAZYROUTER_API_KEY"], "anthropic-version": "2023-06-01"}
rec = {"model": model, "endpoint": BASE + path, "request": payload}
start = time.perf_counter()
try:
with client() as s:
r = s.post(BASE + path, headers=headers, json=payload, timeout=(10, 90), allow_redirects=False)
rec["http"] = r.status_code
if r.status_code == 200:
data = r.json()
rec.update(response_id=data.get("id"), usage=data.get("usage", {}))
if mode == "messages":
output = "".join(x.get("text", "") for x in data.get("content", []) if x.get("type") == "text")
complete = data.get("stop_reason") == "end_turn"
finish = data.get("stop_reason")
elif mode == "responses":
output = "".join(c.get("text", "") for item in data.get("output", []) if item.get("type") == "message" for c in item.get("content", []) if c.get("type") == "output_text")
complete = data.get("status") == "completed"
finish = data.get("status")
else:
choice = data["choices"][0]
output = choice["message"].get("content") or ""
complete = choice.get("finish_reason") == "stop"
finish = choice.get("finish_reason")
rec.update(output=output, complete=complete, finish=finish)
else:
rec["error"] = "HTTP_" + str(r.status_code)
except (requests.RequestException, ValueError, KeyError, IndexError) as error:
rec["error"] = type(error).__name__
rec["seconds"] = round(time.perf_counter() - start, 3)
return rec
def accepted(rec, expected):
if not rec.get("complete"):
return False
try:
return json.loads(rec["output"]) == expected
except (ValueError, TypeError):
return False
def pricing(models):
with client() as s:
r = s.get("https://crazyrouter.com/api/pricing", timeout=(10, 40))
r.raise_for_status()
doc = r.json()
result = {}
for model in models:
row = next((x for x in doc["data"] if x["model_name"] == model), None)
if row is None:
result[model] = {"available": False}
continue
if row.get("billing_mode") not in (None, "", "per_token") or row.get("quota_type") != 0:
raise ValueError("Unreviewed pricing mode")
factor = D(str(doc["group_ratio"]["default"])) * D(str(row["group_discounts"]["default"]))
base = D(str(row["model_ratio"])) * 2 * factor
result[model] = {"available": True, "group": "default", "source_row": row,
"rates": {"input": str(base), "output": str(base * D(str(row["completion_ratio"]))),
"cache": str(base * D(str(row["cache_ratio"]))),
"write5": str(base * D(str(row["cache_creation_ratio"])))}}
return result
def count(value):
if type(value) is not int or value < 0:
raise ValueError("Expected nonnegative integer usage")
return value
def estimate(usage, rates, mode="chat"):
if mode == "messages":
uncached = count(usage.get("input_tokens"))
cached = count(usage.get("cache_read_input_tokens", 0))
written = count(usage.get("cache_creation_input_tokens", 0))
output = count(usage.get("output_tokens"))
if written and usage.get("cache_creation", {}).get("ephemeral_1h_input_tokens", 0):
raise ValueError("One-hour write not priced by this calculator")
return (D(uncached)*D(rates["input"]) + D(cached)*D(rates["cache"]) + D(written)*D(rates["write5"]) + D(output)*D(rates["output"]))/D(1000000)
p, c, detail = ("input_tokens", "output_tokens", "input_tokens_details") if mode == "responses" else ("prompt_tokens", "completion_tokens", "prompt_tokens_details")
prompt, output = count(usage.get(p)), count(usage.get(c))
if 'total_tokens' in usage and count(usage['total_tokens']) != prompt + output:
raise ValueError('Usage totals do not reconcile; no cost estimate emitted')
output_details = usage.get('output_tokens_details' if mode == 'responses' else 'completion_tokens_details') or {}
if count(output_details.get('reasoning_tokens', 0)) > output:
raise ValueError('Reasoning exceeds output counter; no cost estimate emitted')
cached = count(usage.get(detail, {}).get("cached_tokens", 0))
if cached > prompt:
raise ValueError("Cached input exceeds total input")
return (D(prompt-cached)*D(rates["input"]) + D(cached)*D(rates["cache"]) + D(output)*D(rates["output"]))/D(1000000)
def attach_estimate(rec, prices, mode="chat"):
item = prices[rec["model"]]
if rec.get("usage") and item["available"]:
try:
rec["estimated_usd"] = str(estimate(rec["usage"], item["rates"], mode))
except ValueError as error:
rec["estimate_error"] = str(error)
def arithmetic_tests():
rates = {"input": "2", "cache": "0.5", "write5": "2.5", "output": "8"}
cases = [
("uncached", {"prompt_tokens": 100, "completion_tokens": 10}, "chat", "0.00028"),
("cached subset", {"prompt_tokens": 100, "completion_tokens": 10, "prompt_tokens_details": {"cached_tokens": 40}}, "chat", "0.00022"),
("reasoning not added twice", {"input_tokens": 100, "output_tokens": 10, "output_tokens_details": {"reasoning_tokens": 4}}, "responses", "0.00028"),
("native disjoint counters", {"input_tokens": 20, "cache_read_input_tokens": 40, "cache_creation_input_tokens": 60, "output_tokens": 10}, "messages", "0.00029")]
results = []
for label, usage, mode, expected in cases:
assert estimate(usage, rates, mode) == D(expected)
results.append({"case": label, "passed": True})
for label, usage in [("boolean rejected", {"prompt_tokens": True, "completion_tokens": 0}), ("cache overflow rejected", {"prompt_tokens": 1, "completion_tokens": 0, "prompt_tokens_details": {"cached_tokens": 2}}), ("inconsistent total rejected", {"prompt_tokens": 12, "completion_tokens": 5, "total_tokens": 252}), ("reasoning overflow rejected", {"prompt_tokens": 1, "completion_tokens": 2, "completion_tokens_details": {"reasoning_tokens": 5}})]:
try:
estimate(usage, rates)
except ValueError:
results.append({"case": label, "passed": True})
else:
raise AssertionError(label)
return results
def emit(**data):
print(json.dumps(data, ensure_ascii=False))
MODELS = ['MiniMax-M2.5', 'MiniMax-M2.7']
LEGACY = ['MiniMax-M2']
MODE = 'chat'
tests = arithmetic_tests()
available = catalog(LEGACY + MODELS)
prices = pricing(LEGACY + MODELS)
rows = []
for model in MODELS:
if not available[model]:
continue
for label, prompt, expected in [('empty queue', 'Return only JSON {"pending":0}.', {'pending': 0})]:
options = {"max_tokens": 1024}
if MODE == "responses":
options = {"max_output_tokens": 1024, "reasoning": {"effort": "low"}}
elif model.startswith("gpt-5"):
options = {"max_completion_tokens": 1024, "reasoning_effort": "low"}
rec = request(model, prompt, mode=MODE, **options)
rec.update(case=label, passed=accepted(rec, expected))
attach_estimate(rec, prices, MODE)
rows.append(rec)
emit(local_tests=tests, catalog=available, pricing=prices, requests=rows,
scope="Default-group public rate estimate, not actual account debits. No official API, Batch API, hosted search, or cache-hit experiment performed.")

Sources and related guides#
Documentation checked November 4, 2026: MiniMax pricing overview, MiniMax text model guide. The test table describes gateway observations, not vendor-native account measurements.
- Kimi K2 Thinking API Recheck: Verify the Exact ID Before a Workflow
- GPT-5.2 API Pricing: Test Two Requests and Reconcile Usage
- AI SaaS Unit Economics: Calculate Cost per Usable Output
- One API Key for Multiple AI Models: Catalog Access and Live Route Tests
- Open-Weight vs Commercial Model APIs: Test the Output Contract Before Switching
FAQ#
Was MiniMax-M2 called?#
No. That exact ID was absent.
Which routes were called?#
MiniMax-M2.5 and MiniMax-M2.7.
Did both pass the test?#
Yes, for the one strict JSON fixture used here.
Are the amounts account charges?#
No. They are calculations from public configuration and response usage.
Is M2.7 better overall?#
This test cannot establish that; it used one simple task.
Was the native MiniMax endpoint used?#
No. All live calls used the Crazyrouter gateway.
Last actually tested: November 4, 2026. This API-dependent article is due for review December 4, 2026.
Implementation Guides
Podcast
AI Dev Tools: The Crazyrouter Podcast
Short episodes for developers on AI APIs, gateways, cost control and coding tools.
Latest episodes
EP196 · Oct 29, 2026 · 6:53
AI API Security Posture — Turn Controls Into Continuous Evidence
A practical guide to AI API security posture: inventory exposure, verify controls continuously, protect keys and data, constrain tools, and turn security assumptions into evidence that operators can act on.
EP195 · Oct 28, 2026 · 7:21
AI API Policy Drift — Detect When Production Rules Stop Matching Intent
A practical guide to policy drift in AI APIs: version routing and safety rules, detect stale enforcement, compare intended and observed behavior, and restore control before small gaps become incidents.





