Back to Blog
EnglishPricing

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.

B
Boluo Z
April 27, 2026 / 973 views
Share:
MiniMax M2 Pricing: Check the Missing ID and Measure Two Current Routes

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 IDVisible to credential
MiniMax-M2No; no call under this name
MiniMax-M2.5Yes
MiniMax-M2.7Yes
ModelDefault-group input USD / 1MCached input USD / 1MOutput USD / 1M
MiniMax-M2.50.300.301.20
MiniMax-M2.70.300.0601.20
Route / fixtureHTTP / errorTerminal stateAcceptedOutput or errorResponse IDUsageUSD estimate
MiniMax-M2.5 / empty queue200stopYes{"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 queue200stopYes{"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 checkResult
uncachedPassed
cached subsetPassed
reasoning not added twicePassed
native disjoint countersPassed
boolean rejectedPassed
cache overflow rejectedPassed
inconsistent total rejectedPassed
reasoning overflow rejectedPassed

MiniMax M2 Pricing: Check the Missing ID and Measure Two Current Routes: observed route results for the stated fixtures

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.

python
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.")

MiniMax M2 Pricing: Check the Missing ID and Measure Two Current Routes: local checks or observed usage and estimates

Documentation checked November 4, 2026: MiniMax pricing overview, MiniMax text model guide. The test table describes gateway observations, not vendor-native account measurements.

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.

Episodes with written show notes →

Topics

API GuidesPricing

Related Articles

GPT-5 Mini Pricing: Check Cached Input Separately from the Headline DiscountPricing

GPT-5 Mini Pricing: Check Cached Input Separately from the Headline Discount

A current gpt-5-mini gateway rate check, two live JSON requests and five Decimal fixtures separate usage estimates from actual billing and untested discounts.

Apr 27
GPT-5.2 API Pricing: Test Two Requests and Reconcile UsagePricing

GPT-5.2 API Pricing: Test Two Requests and Reconcile Usage

Two GPT-5.2 JSON requests passed a declared strict contract. Current gateway default-group rates and eight local calculator checks produce estimates without claiming measured caching or Batch API savings.

Apr 27
GPT-5 Pricing Explained — Reasoning Tokens, Caching, Batch API, and How to Save with CrazyrouterPricing

GPT-5 Pricing Explained — Reasoning Tokens, Caching, Batch API, and How to Save with Crazyrouter

Complete breakdown of GPT-5 API pricing — $1.25/$10 per MTok, reasoning tokens billed as output, automatic caching at 10%, Batch API 50% off, and Crazyrouter savings.

Apr 27
DeepSeek V4 Pro Pricing: Test Peak, Off-Peak and Cached-Input EstimatesTutorial

DeepSeek V4 Pro Pricing: Test Peak, Off-Peak and Cached-Input Estimates

A current deepseek-v4-pro gateway rate check, two live JSON requests and five Decimal fixtures separate usage estimates from actual billing and untested discounts.

Oct 11
Gemini 3 Pro Pricing Queries: Verify the Model Version and Recheck 3.1 ProGuide

Gemini 3 Pro Pricing Queries: Verify the Model Version and Recheck 3.1 Pro

A current gemini-3.1-pro gateway rate check, two live JSON requests and five Decimal fixtures separate usage estimates from actual billing and untested discounts.

Oct 13
GPT-5 API Pricing per 1M Tokens: From Rate Card to a Checked EstimateGuide

GPT-5 API Pricing per 1M Tokens: From Rate Card to a Checked Estimate

A current gpt-5 gateway rate check, two live JSON requests and five Decimal fixtures separate usage estimates from actual billing and untested discounts.

Oct 11