MODELLIX editorial cover showing a glass M3 chip fed by text, image and video streams beside the headline MiniMax M3 API Integration Guide & Pricing

MiniMax M3 is MiniMax’s current flagship M-series model, and it has a real, documented API you can call today with an OpenAI-compatible or Anthropic-compatible client. The model string is MiniMax-M3, the context window is 1,000,000 tokens (input and output combined), the input accepts text, images, and video, and official pay-as-you-go pricing is $0.30 per million input tokens and $1.20 per million output tokens at the standard tier up to 512k input tokens — every number in this guide re-pulled from official sources on September 6, 2026.

One honest disclosure before the code. Modellix is an AI model API aggregator and has a commercial interest in this article. MiniMax M3 is not available on Modellix’s LLM text gateway as of this date — we checked, and MiniMax text models are not listed there. What Modellix does route is MiniMax’s media family (Hailuo and MiniMax-H3 video, speech), and we say that plainly in the routing section instead of pretending the text model is in our catalog. Everything else here is vendor-neutral integration material you can use with or without us.

What MiniMax M3 is and why it matters

MiniMax launched M3 on June 1, 2026, as the successor to the M2 line (M2.5, M2.7), and the launch announcement is explicit about the three capabilities it is combining: frontier-level coding and agentic work, a 1-million-token context window, and native multimodal input. The architecture behind the long context is MiniMax Sparse Attention (MSA), a sparse-attention scheme that MiniMax says cuts per-token compute at 1M context to roughly one-twentieth of the previous generation’s full-attention design.

What those claims mean for you as an API consumer, from the official model page and the API reference overview, both fetched September 6, 2026:

  • Model ID: MiniMax-M3 (case-sensitive), listed as the current M-series model for agentic reasoning, tool use, coding, and long-context tasks. M2.7 stays available alongside it; M2.5 and earlier are in MiniMax’s Legacy bucket.
  • Context window: 1,000,000 tokens total. MiniMax’s product page states a guaranteed minimum of 512K hosted context, and the API docs note that the 1M figure is the combined input-plus-output budget, not 1M of input with an unlimited answer on top.
  • Modalities: text, image, and video in; text out. This is the first M-series model trained multimodal from the start, so the vision input is not an add-on bolt-on.
  • Output speed: roughly 100+ tokens per second per MiniMax’s model table.
  • Open weights: MiniMax positions M3 as the first open-weight model with this capability combination, and the weights repository is live on Hugging Face — useful to know for self-hosting conversations, though this guide sticks to the hosted API.
  • Benchmarks with a caveat: MiniMax reports strong coding numbers (for example 59.0% on SWE-Bench Pro, above GPT-5.5 at 58.6% in its own comparison). Those are vendor-reported figures from launch week, so treat them as directional and re-test on your own workloads — several independent reviewers have noted the gap between MiniMax’s headline runs and third-party agent evaluations.
Text, image and video input cards feeding a central MiniMax-M3 chip, with a single text output stream

M3 takes text, image, and video input but always answers in text — worth knowing before you design request payloads. Diagram generated September 6, 2026.

If you are coming from the M2 generation, our MiniMax 2.5 API guide covers the legacy side of the family and why MiniMax still serves it; this article is about the model MiniMax wants you to build on now.

MiniMax M3 API pricing, pulled September 6, 2026

The rates below were read from the official pay-as-you-go pricing guide on September 6, 2026, and are per 1M tokens. MiniMax labels the standard prices a permanent 50% discount from list, which is why you may see $0.60/$2.40 struck through in the docs:

Service tier Input length Input / M Output / M Cache read / M
Standard ≤ 512k input tokens $0.30 $1.20 $0.06
Standard > 512k input tokens $0.60 $2.40 $0.12
Priority ≤ 512k input tokens $0.45 $1.80 $0.09
Priority > 512k input tokens $0.90 $3.60 $0.18

Four readings of that table that are easy to miss:

  1. The 512k cliff is the real cost story. M3 advertises a 1M window, but the price is not flat across it. A request whose input crosses 512k tokens lands in the above-512k band and pays double on input, output, and cache reads. If your agent workload routinely sends 600k-token repository snapshots, budget for the higher band — that is the difference between $0.30/M and $0.60/M on most of your input volume.
  2. Priority is a routing tier, not a quality tier. Set service_tier: "priority" on a request and it costs 1.5× standard but gets priority admission — faster responses and fewer failures under load, per MiniMax’s docs. Same model, same output quality; you are paying for queue position.
  3. Prompt caching is automatic and cheap. MiniMax’s passive caching needs no configuration: cache-hit input reads at $0.06/M instead of $0.30/M at the standard band. Keep your system prompt, tool definitions, and long reference material byte-stable at the front of the request and repeated calls get markedly cheaper.
  4. A worked example. A 200k-token input with a 20k-token answer at Standard ≤512k costs 0.2 × $0.30 + 0.02 × $1.20 = $0.084. If 150k of that input hits cache, input drops to 50k × $0.30 + 150k × $0.06 = $0.024, for a total of $0.048 — 43% cheaper on that request, and the gap grows with reuse.

Marketplace routes set their own prices on top of these. The OpenRouter page for minimax/minimax-m3 shows the official MiniMax row at $0.30/$1.20 and several hosts undercutting from around $0.23/$0.96, in exchange for an extra hop and their own rate limits. For the full picture of MiniMax’s pricing family across models and media — including the Token Plan subscription system, which bills through a separate Subscription Key — our MiniMax pricing guide has the complete table.

Getting a MiniMax M3 API key

Keys live in the MiniMax platform console at platform.minimax.io. Per the official prerequisites guide: sign in, open API Keys, click Create new secret key, and copy the key immediately — it is displayed exactly once.

Two distinctions matter more than the click path:

  • Pay-as-you-go vs Token Plan. The default secret key is billed per token against your balance. Token Plan is a separate monthly-quota subscription that issues its own Subscription Key (keys with the sk-cp prefix). The two are not interchangeable: a pay-as-you-go key cannot spend Token Plan quota, and a Subscription Key will fail against pay-as-you-go endpoints. MiniMax recommends pay-as-you-go for production. Creating a key does not require a credit card; you top up when you start spending.
  • Region isolation. The international platform (platform.minimax.io, API host api.minimax.io) and the China platform (platform.minimaxi.com) are separate — a key issued on one will not authenticate on the other. Export the key as an environment variable rather than pasting it into code:
1
export MINIMAX_API_KEY="your-key-here"

There is no official free tier for MiniMax M3 — no signup credits and no free quota on the text API as of this date. The only rate-limited free routes we know of are third-party ones such as OpenRouter’s :free variants of newer MiniMax models, which are fine for experiments and not for production. Our step-by-step guide to getting a MiniMax API key walks the console with screenshots if you want the visual tour.

Base URLs: two compatible endpoints, one model

MiniMax serves M3 through two interchangeable protocol surfaces on the same backend, per the official model invocation guide:

Compatibility Base URL Best fit
Anthropic-compatible (MiniMax’s recommendation) https://api.minimax.io/anthropic Anthropic SDKs, Claude-style agents, interleaved thinking, prompt-cache benefits
OpenAI-compatible https://api.minimax.io/v1 OpenAI SDKs, Codex/Cursor-style tooling, Chat Completions or Responses APIs

This “one model, two doors” design is the single biggest integration shortcut MiniMax offers: if you already have an OpenAI or Anthropic SDK client in production, switching models is a two-line change — swap base_url and model and your existing auth, retries, and streaming keep working. No MiniMax-specific SDK is required. Model-list endpoints exist on both surfaces (GET /v1/models and GET /anthropic/v1/models) so you can confirm availability programmatically. For the China region, replace the host with api.minimaxi.com and keep the same paths.

Two client nodes labeled OpenAI-compatible /v1 and Anthropic-compatible /anthropic feeding one central MiniMax-M3 gateway at api.minimax.io

Both protocol doors hit the same MiniMax-M3 backend, so one key works with either SDK family. Diagram generated September 6, 2026.

One warning that will save you a debugging session: MiniMax’s old native text endpoint (POST /v1/text/chatcompletion_v2) still appears in older examples and even on MiniMax’s own product page, but the API docs mark it deprecated. Start new integrations on the OpenAI Chat Completions or Anthropic Messages surfaces — that is where current parameters, thinking control, and multimodal content are documented. If you are new to the compatibility-layer pattern itself, our OpenAI-compatible API explainer covers how these gateways map one model onto many SDKs.

Calling MiniMax M3: curl and SDK examples

curl against the OpenAI-compatible endpoint — note thinking explicitly disabled for a direct answer, and max_completion_tokens as the modern length field:

1
2
3
4
5
6
7
8
9
10
11
curl https://api.minimax.io/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -d '{
    "model": "MiniMax-M3",
    "messages": [
      {"role": "user", "content": "Explain the 512k pricing cliff in MiniMax M3 in two sentences."}
    ],
    "thinking": {"type": "disabled"},
    "max_completion_tokens": 512
  }'

Python with the OpenAI SDK:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import os
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-M3",
    messages=[{"role": "user", "content": "Draft a retry wrapper with exponential backoff."}],
    max_completion_tokens=1024,
)
print(resp.choices[0].message.content)

Python with the Anthropic SDK — MiniMax’s recommended route:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import os
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-M3",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Compare M3 and M2.7 context windows in one paragraph."}],
)
print(resp.content[0].text)

Multimodal input uses the standard content-array shape. Per the Chat Completions reference, M3 message content can mix text, image_url, and video_url parts — on the OpenAI-compatible client, recreated here so this snippet runs standalone:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import os
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-M3",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What is in this image and this video clip?"},
            {"type": "image_url", "image_url": {"url": "https://example.com/diagram.png"}},
            {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}},
        ],
    }],
    max_completion_tokens=1024,
)

Images can be JPEG/PNG/GIF/WebP up to 10 MB each, and image input consumes tokens roughly by a detail setting — low usually a few hundred tokens, default around 1k–3k, high several thousand up to 15k+. Videos run up to 50 MB as a URL or base64 payload (512 MB through the Files API via mm_file:// references). That means multimodal requests can burn a meaningful chunk of your 1M context before the model says a word.

Two behaviors to know before you tune prompts, from the OpenAI SDK reference:

  • Thinking is on by default for M3 on the OpenAI-compatible surface. If you omit thinking, responses include reasoning content and take longer. Set thinking: {"type": "disabled"} for low-latency direct answers, or {"type": "adaptive"} to keep thinking explicitly on. Pass reasoning_split: true to separate the reasoning into its own reasoning_content / reasoning_details fields instead of <think> tags inline. (M2.x models cannot disable thinking — another quiet reason M3 is the better integration target.) One protocol difference to plan for: on the Anthropic-compatible surface (/anthropic, MiniMax’s recommended route), thinking is off by default and enabled with thinking: {"type": "adaptive"} — the two doors ship opposite defaults, so read the qualifier on whichever endpoint you standardize on.
  • Use max_completion_tokens, not max_tokens, for new integrations; the latter is the legacy field. Defaults worth knowing: temperature ranges [0, 2] with default 1, and top_p defaults to 0.95 for M3.

Streaming and tool calling work through the standard flags — stream: true emits SSE chunks in the shapes your OpenAI or Anthropic client already handles, and tools accepts ordinary function schemas.

Errors, limits, and gotchas nobody warns about

MiniMax returns application-level errors inside the response body as base_resp.status_code rather than as HTTP status codes. An HTTP 200 response can still be a failed business call, so validate the body, not just the transport. The codes below come from MiniMax’s official error-code reference:

base_resp.status_code Meaning First action
2049 Invalid API key Re-copy the key — whitespace or line breaks are the usual culprit
1004 Not authorized / token mismatch Wrong key, revoked key, or region mismatch (intl vs China platform)
1008 Insufficient balance Top up at Billing → Balance
1002 Rate limit Back off and retry with exponential delay
1039 Token limit Your request exceeds the context budget — trim input or output

Beyond the codes, five gotchas cost people real time:

  1. The 1M window is shared between input and output. A 900k-token input leaves only ~100k tokens for the answer. Plan max_completion_tokens against what the input is already consuming, or the call fails at the limit you least expect.
  2. The >512k band is not an upsell — it is the same model. You do not get a “long-context version” above 512k; you get the same M3 at double the per-token rate. If a workload fits under 512k, there is no quality reason to cross the line.
  3. Key types and regions are silently incompatible. sk-cp Subscription Keys fail on pay-as-you-go endpoints with 1004/1008-style errors; an international key fails against api.minimaxi.com. Both failure modes look like “wrong key” and are actually “wrong key system.”
  4. Old examples will steer you to a deprecated endpoint. MiniMax’s own marketing pages still show chatcompletion_v2; the docs call it deprecated. If a tutorial’s base URL does not look like /v1 or /anthropic, treat the tutorial as stale.
  5. Thinking doubles as a cost control. Thinking on by default on the OpenAI-compatible surface (and on whenever you set adaptive on the Anthropic surface) means your billable output includes reasoning tokens you may not need. For classification, extraction, and short transforms, disabling thinking — or staying on the default-off Anthropic route without enabling it — cuts both latency and spend.

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

M2.7 is not deprecated — MiniMax still lists it as an active model at 204,800 tokens context, text-and-tools input, same $0.30/$1.20 standard rates, and it remains the right call for some workloads. The decision rule as of September 2026:

  • Choose MiniMax-M3 when you need more than ~200k tokens of usable context, when image or video input matters, when you want controllable reasoning (thinking on/off) for agentic pipelines, or when you want the model MiniMax is actively developing. At the ≤512k standard band the price is identical to M2.7, so the long-context capability is close to free until you actually use it.
  • Stay on MiniMax-M2.7 for short, text-only, high-volume workloads that never approach 200k tokens and are already tuned and stable. Same token price, lower risk of surprise output-token spend from thinking, and a -highspeed variant exists if you want ~100 tps on that generation.

The honest tiebreaker: if a teammate asks “why are we still calling the old model?”, the defensible answers are “our prompts are tuned against it and it is stable” or “we never exceed 200k tokens and do not need vision input.” If neither is true, M3 is the default for new integrations. The full M-series ladder — including when the M2.5 generation still earns its keep — is covered in the two MiniMax guides linked above if you are still deciding across generations.

MiniMax M3 on Modellix: the honest answer

We checked Modellix’s LLM text gateway on September 6, 2026: MiniMax text models — MiniMax-M3 included — are not listed there, and we are not going to claim otherwise. Modellix’s MiniMax catalog is its media family, visible on the MiniMax provider page: Hailuo and MiniMax-H3 video generation (text-to-video, image-to-video, first/last-frame, video-to-video), speech synthesis, and voice cloning — 13 models as of September 2026, behind one unified REST API and one key.

So where does Modellix actually fit for an M3 developer? Two honest answers — and one host-boundary note: Modellix runs two separate surfaces, the text gateway at llm.modellix.ai (which does not list MiniMax) and the media APIs at api.modellix.ai (where the MiniMax media family lives). Don’t blur the two hosts when you wire up either side.

  1. If you pair an LLM with generated media, Modellix is the one-key route for the media half of that pipeline — call MiniMax-H3 for video and MiniMax Speech for voice alongside the rest of the 210+ model catalog without juggling vendor consoles. That workflow is exactly what our one-API multi-model article walks through.
  2. If you need MiniMax text models through an aggregator today, you want a gateway that actually lists them — OpenRouter and several others carry minimax/minimax-m3 — and you should check their current status before wiring anything up, because model catalogs change monthly.

Modellix REST API Reference

One REST contract for 210+ image and video models — see the request, polling, and billing reference for the media APIs Modellix does serve.

View Docs

Run MiniMax Media Models on One Key

Log in to Modellix to call Hailuo and MiniMax-H3 video and speech alongside 210+ other image and video models with a single API key.

Login

Frequently Asked Questions

Does MiniMax M3 have an API?

Yes. MiniMax-M3 is served through MiniMax’s platform at api.minimax.io with two compatible surfaces: OpenAI-compatible (/v1) and Anthropic-compatible (/anthropic, recommended). No MiniMax-specific SDK is required — existing OpenAI or Anthropic clients work after swapping base URL and model string.

How do I get a MiniMax M3 API key?

Sign in to platform.minimax.io, open API Keys, and click Create new secret key. The key displays once, so copy it immediately. Pay-as-you-go keys and Token Plan Subscription Keys (sk-cp) are separate billing systems and are not interchangeable.

What is the MiniMax M3 API base URL?

https://api.minimax.io/v1 for OpenAI-compatible clients and https://api.minimax.io/anthropic for Anthropic-compatible clients. China-region accounts use api.minimaxi.com with the same paths.

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

As of September 6, 2026, at the standard tier with up to 512k input tokens: $0.30/M input, $1.20/M output, $0.06/M cache read. Above 512k input tokens the rates double to $0.60/$2.40/$0.12. A Priority tier (service_tier: "priority") costs 1.5× standard.

What is MiniMax M3’s context window?

1,000,000 tokens total — and that figure is the combined input-plus-output budget. MiniMax guarantees a hosted minimum of 512K context; inputs above 512k tokens are billed at the higher rate band.

Is MiniMax M3 multimodal?

Yes — it accepts text, image, and video input and returns text. Images up to 10 MB (JPEG/PNG/GIF/WebP); videos up to 50 MB directly or 512 MB through the Files API.

Is there a free MiniMax M3 API?

No official free tier exists for MiniMax text models — no signup credits, no free quota. Third-party routes like OpenRouter’s :free variants of newer MiniMax models are rate-limited and suited to experiments only.

Can I call MiniMax M3 through Modellix?

Not the text model — as of September 6, 2026, MiniMax LLMs are not on Modellix’s LLM gateway. Modellix does serve MiniMax’s media models (Hailuo and MiniMax-H3 video, speech) through one API key.

MiniMax model status, pricing, and endpoint details reflect public information as of September 6, 2026 and change frequently — MiniMax has moved models in and out of its lineup within a single quarter, and prices carry promotional labels that shift. 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 M3 integration material above is vendor-neutral. Access 210+ image and video models, including MiniMax’s media family, through one API key at modellix.ai.