MODELLIX editorial cover for the MiniMax 2.5 API integration guide showing two base URLs flowing into one API gateway

Yes — MiniMax 2.5 has a real, documented API, and it is callable today with an OpenAI-compatible or Anthropic-compatible client. The MiniMax 2.5 API is served from api.minimax.io with two interchangeable base URLs, costs $0.30 per million input tokens and $1.20 per million output tokens on official pay-as-you-go pricing, and works through the model string MiniMax-M2.5. This guide assembles what the official docs spread across five pages — model identity, pricing, key setup, base URLs, working code, and failure modes — into one place, with every number re-pulled on August 28, 2026.

One honest disclosure before the code: Modellix is an AI model API aggregator and has a commercial interest in this article. MiniMax 2.5 is not available on Modellix’s LLM gateway as of this date — we checked, and it is not listed there. What Modellix does serve is MiniMax’s media models (Hailuo video, image, speech), and we say so plainly in the routing section rather than pretending the text model is part of our catalog. Everything in between is vendor-neutral integration material you can use with or without us.

What MiniMax 2.5 is in 2026: a legacy model that still ships

MiniMax-M2.5 is the company’s code-optimized M-series LLM, launched in February 2026 and marketed around “Peak Performance. Ultimate Value” — its selling point was strong coding and agentic behavior at a competitive price point. The official model catalog now lists it under Legacy Models, alongside M2.5-highspeed, M2.1, and M2. The current lineup is MiniMax-M3 (1M context, frontier coding) and MiniMax-M2.7.

That legacy label is the most important fact about this model in 2026, and it is the one every ranking page hides. “Legacy” here does not mean dead: the text-generation guide still documents MiniMax-M2.5 as a supported model, the endpoints accept it, and billing continues on the standard pay-as-you-go table. It means MiniMax has stopped adding features to it and is steering new integrations toward M2.7 and M3. If you pick M2.5 today, you are making a deliberate cost-versus-future-proofing trade, not a mistake.

The specs that matter for integration, from the API reference overview:

  • Context window: 204,800 tokens (input and output combined)
  • Throughput: ~60 tokens/second output; the MiniMax-M2.5-highspeed variant keeps identical output quality at roughly 100 tps
  • Modalities: text in, text out — no native image or video input
  • Third-party benchmark (reported on the OpenRouter model page, fetched August 28, 2026): 80.2% SWE-Bench Verified, 51.3% Multi-SWE-Bench, 76.3% BrowseComp — strong coding numbers, but treat benchmarks as directional, not guarantees

MiniMax 2.5 API pricing, pulled today

The official pay-as-you-go rates below were read from the MiniMax pricing guide on August 28, 2026, and are per 1M tokens:

Model Input Output Cache read
MiniMax-M2.5 $0.30 $1.20 $0.03
MiniMax-M2.5-highspeed $0.60 $2.40 $0.03
MiniMax-M2.7 $0.30 $1.20 $0.06
MiniMax-M3 (≤512k input) $0.30 $1.20 $0.06

Three practical readings of that table:

  1. M2.5 is priced identically to M2.7 — $0.30/$1.20 per million tokens on both. The legacy model saves you nothing per token versus its current successor at the same context tier, which is a strong argument for defaulting new integrations to M2.7 (more on this in the selection section).
  2. M2.5-highspeed costs 2× standard ($0.60/$2.40) for roughly 1.7× the output speed. It earns its premium only when latency per request is the constraint.
  3. Prompt caching cuts real cost. Cached input tokens on M2.5 read at $0.03/M — one-tenth of the uncached input rate. If your workload sends the same system prompt or tool definitions repeatedly, cache hits turn the effective input price into pocket change.

For a worked example: a 100k-token request with 50k output tokens costs 100 × $0.30 + 50 × $1.20 = $0.09 on M2.5 direct. If 80k of those input tokens hit cache, input drops to 20 × $0.30 + 80 × $0.03 = $0.006 + $0.0024 = $0.0084; add the 50k output tokens (50 × $1.20 = $0.06) and the request totals $0.0684 — 24% cheaper than the uncached $0.09 on that request, and the gap grows with cache reuse.

MiniMax text model tier cards showing M2.5, M2.5-highspeed, M2.7 and M3 arranged from legacy to current flagship

The MiniMax text model ladder from legacy M2.5 to the current M3 flagship — no prices, because they drift. Diagram generated August 28, 2026.

Two other pricing systems exist and are worth naming so you do not confuse them. Token Plan is MiniMax’s subscription-style quota system, billed monthly with a separate Subscription Key — it is a different billing universe from pay-as-you-go, not a discount applied to it. And marketplace routes set their own prices: the OpenRouter route for minimax/minimax-m2.5 lists $0.27/M input and $1.08/M output as of August 28, 2026 (read from its models API, not the page), marginally below official direct rates — the usual marketplace pattern of a few percent off in exchange for an extra hop. For the full breakdown of MiniMax’s pricing family across models and media, our MiniMax pricing guide has the complete table.

Getting a MiniMax 2.5 API key (and which key type you need)

Keys live in the MiniMax platform console at platform.minimax.io. Sign in, open API Keys, and click Create new secret key — the key is displayed exactly once, so copy it before closing the dialog. Creating a key does not require a credit card; you top up billing only when you start spending.

The critical distinction is which billing system your key belongs to, because it changes the key itself:

  • Pay-as-you-go — the default. A secret key billed per token at the table above. This is the key type for the code in this guide.
  • Token Plan — a monthly quota subscription. It issues a separate Subscription Key (prefix sk-cp) that only works against Token Plan billing. A pay-as-you-go key cannot spend Token Plan quota and vice versa.

There is also a platform split worth remembering: the international platform (platform.minimax.io / api.minimax.io) and the China platform (platform.minimax.cn) are isolated — a key issued on one will not authenticate on the other. Our guide to getting a MiniMax API key walks through the console step by step if you want screenshots.

One expectation to set now: there is no official free tier for MiniMax M2.5. No signup credits, no free quota on the text API. The only “free” endpoints MiniMax has ever published were the free music models, which were discontinued for new users in August 2026. Third-party free routes exist — OpenRouter currently offers rate-limited :free variants of M3 and M2.7, but not M2.5 as of this date — and they are worth checking for experimentation. The honest picture of what “free” means across MiniMax today is in our MiniMax free API article.

Base URLs: one model, two compatible endpoints

MiniMax runs an OpenAI-compatible and an Anthropic-compatible surface on the same backend. From the official text-generation guide:

Compatibility Base URL
Anthropic-compatible (recommended) https://api.minimax.io/anthropic
OpenAI-compatible https://api.minimax.io/v1

That “one model, two doors” design is the single biggest integration shortcut MiniMax offers: if you already have an OpenAI SDK client or an Anthropic SDK client in production, switching models is a two-line change — swap base_url and model and your existing plumbing (auth, retries, streaming) keeps working. No MiniMax-specific SDK required. The model string is exactly MiniMax-M2.5 (case-sensitive), or MiniMax-M2.5-highspeed for the fast variant.

Calling MiniMax 2.5: curl and SDK examples

curl against the OpenAI-compatible endpoint — the same shape as any OpenAI chat completion:

1
2
3
4
5
6
7
8
9
10
11
12
curl https://api.minimax.io/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -d '{
    "model": "MiniMax-M2.5",
    "messages": [
      {"role": "system", "content": "You are a senior code reviewer."},
      {"role": "user", "content": "Review this function for edge cases: def parse(data): return data.strip().split(',')"}
    ],
    "stream": false,
    "max_tokens": 1024
  }'

Python with the OpenAI SDK — install openai, point it at the MiniMax base URL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MINIMAX_API_KEY"],
    base_url="https://api.minimax.io/v1",
)

resp = client.chat.completions.create(
    model="MiniMax-M2.5",
    messages=[
        {"role": "system", "content": "You write concise, correct Python."},
        {"role": "user", "content": "Write a retry wrapper with exponential backoff."},
    ],
)
print(resp.choices[0].message.content)

Python with the Anthropic SDK — the documented “recommended” route:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["MINIMAX_API_KEY"],
    base_url="https://api.minimax.io/anthropic",
)

resp = client.messages.create(
    model="MiniMax-M2.5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain the difference between M2.5 and M2.7 in one paragraph."},
    ],
)
print(resp.content[0].text)
Two input pipelines labeled OpenAI-compatible and Anthropic-compatible merging into one MiniMax API gateway

Both compatibility routes hit the same MiniMax gateway, so one key works with either SDK. Diagram generated August 28, 2026.

Two production notes that apply to both routes:

  • Streaming works through the standard flag — stream: true on the OpenAI side, stream=True in the Anthropic SDK — and emits SSE chunks with the same shapes you already handle. No MiniMax-specific streaming protocol.
  • Tool calling uses the standard tools parameter. On the OpenAI surface, define functions in the familiar JSON schema and M2.5 will emit tool_calls; on the Anthropic surface, pass tools with the block format. The model string and base URL are the only MiniMax-specific parts of your code.

Errors, limits, and the gotchas nobody pages warn about

MiniMax returns API errors inside the response body as base_resp.status_code — not as HTTP status codes. A 200 HTTP response can still carry a failed business call, so check the body. The four errors new integrators hit, per MiniMax’s API documentation and the current error reference:

base_resp.status_code Meaning Fix
2049 Invalid API key Re-copy the key — whitespace and line breaks are the usual culprit
1004 Not authorized Wrong key, revoked key, or platform mismatch (intl vs China)
1008 Insufficient balance Top up at Billing > Balance
1002 Rate limit Back off and retry with exponential delay

Beyond the error codes, four gotchas cost people real time:

  1. Token Plan vs pay-as-you-go keys are not interchangeable — a sk-cp Subscription Key will fail on pay-as-you-go endpoints with 1004/1008-style errors, and the console makes the distinction easy to miss.
  2. “Legacy” status is invisible until it bites. M2.5 works, but new features (new tool types, context extensions, multimodal inputs) land on M3/M2.7 first. Budget for a migration, not for M2.5 to keep improving.
  3. Caching only saves money if you structure requests for it. Cache hits require identical prefix content — put your system prompt and tool definitions first and keep them byte-stable, or you will never see the $0.03/M cache rate.
  4. Prices and model status change fast. This article’s numbers are frozen at August 28, 2026; MiniMax has already moved models in and out of “legacy” within a single quarter. Re-pull the official pricing page before committing budget.

MiniMax 2.5 vs M2.7 vs M3: which model should you call?

Three-way selection, as of August 2026:

  • MiniMax-M2.5 — pick it when your pipeline already targets it, your prompts are tuned against its quirks, and you are optimizing for stability over new features. At $0.30/$1.20 it is not cheaper than M2.7, so the argument is “it works and we know it,” not “it’s the budget option.”
  • MiniMax-M2.7 — the sensible default for new integrations that want the same 204,800-token context and the same price, with current-model support. If you are starting from scratch today, this is usually the answer.
  • MiniMax-M3 — the frontier model: 1M context, stronger agentic coding, and — notably — the same $0.30/$1.20 rate as M2.5 up to 512k input tokens. Above that it doubles to $0.60/$2.40. For long-context agent workloads M3 is the value pick, not the luxury pick.

The honest bottom line: if a teammate asks “why are we calling a legacy model?”, the defensible answers are (a) it is already integrated and battle-tested in our stack, or (b) we need a cheap code model and M3’s long-context features are irrelevant to us. If neither applies, M2.7 or M3 is the better choice, and this article exists because searchers deserve to know that before they wire up M2.5.

Where Modellix fits — MiniMax media, not MiniMax text. We checked Modellix’s LLM gateway on August 28, 2026: MiniMax text models (M2.5, M2.7, M3) are not on it, and we are not going to claim otherwise. What Modellix does route is MiniMax’s media family — Hailuo video models, image generation, and speech synthesis — through the MiniMax provider page and one unified REST API. If your project pairs an LLM with generated media, that is the one-key-for-many-model-families workflow. A Hailuo text-to-video call on Modellix looks like this, from the Modellix API docs:

1
2
3
4
curl -X POST https://api.modellix.ai/api/v1/minimax/hailuo-2.3-t2v \
  -H "Authorization: Bearer $MODELLIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A glass factory at night, molten glass glowing amber, slow dolly shot"}'

Modellix REST API Reference

One REST contract for 210+ image and video models — see the full request, polling, and billing reference.

View Docs

A fair comparison so you can budget correctly: Hailuo 2.3 T2V on Modellix runs $0.0504/sec at 768P and $0.0738/sec at 1080P (from the model page, August 28, 2026). We are not claiming that undercuts MiniMax direct — the two price sheets are quoted in different units, so there is no single number to line up: Modellix bills per second of video, while MiniMax’s direct Hailuo pricing is per task (per generation, set by resolution and duration), which means the cheaper route depends on your clip rather than on one headline rate. The aggregator’s value is operational: one key, one bill, consistent task APIs across 210+ models from many vendors, not a guarantee of the cheapest per-call rate on every model.

Run MiniMax Media Models on One Key

Log in to Modellix to call Hailuo video, image, and speech alongside 200+ other models with one API key.

Login

Frequently Asked Questions

Does MiniMax 2.5 have an API?

Yes. MiniMax-M2.5 is served through MiniMax’s platform at api.minimax.io, with both an OpenAI-compatible endpoint (/v1) and an Anthropic-compatible endpoint (/anthropic). No separate SDK is required — existing OpenAI or Anthropic clients work after swapping base URL and model string.

How do I get a MiniMax 2.5 API key?

Sign in to platform.minimax.io, open API Keys, and click Create new secret key. The key shows once — copy it immediately. No credit card is required to create it; you top up when you start spending.

What is the MiniMax 2.5 API base URL?

Two options: https://api.minimax.io/v1 (OpenAI-compatible) and https://api.minimax.io/anthropic (Anthropic-compatible, recommended by MiniMax). The model string is MiniMax-M2.5.

How much does the MiniMax 2.5 API cost per million tokens?

As of August 28, 2026: $0.30/M input and $1.20/M output on pay-as-you-go, with cached input at $0.03/M. The MiniMax-M2.5-highspeed variant is $0.60/$2.40. MiniMax M2.7 is priced identically to M2.5.

Is there a free MiniMax 2.5 API?

No official free tier exists for MiniMax text models — no signup credits, no free quota. OpenRouter hosts rate-limited :free variants of newer models (M3, M2.7) but not M2.5 as of August 28, 2026.

Is MiniMax M2.5 still supported?

Yes. It is listed as a Legacy Model — MiniMax has stopped adding features but still serves it, documents it, and bills it on the standard pricing table. The supported model strings include MiniMax-M2.5 and MiniMax-M2.5-highspeed.

What is MiniMax M2.5’s context window?

204,800 tokens (input and output combined), with ~60 tokens/second output throughput; the highspeed variant roughly doubles output speed at 2× the token price.

Can I call MiniMax 2.5 through Modellix?

Not the text model — as of August 28, 2026, MiniMax LLMs are not on Modellix’s LLM gateway. Modellix does serve MiniMax’s media models (Hailuo video, image, speech) through a single API key.

MiniMax model status and pricing reflect public information as of August 28, 2026 and change frequently; MiniMax has moved models in and out of its legacy list within a single quarter. Re-validate against the official pricing and model pages before committing budget. This article was written by Modellix, an API aggregator with a commercial interest in MiniMax media models — the M2.5 integration material above is vendor-neutral. Access 210+ image and video models, including MiniMax’s media family, through one API key at modellix.ai.