MiniMax M3.1 Flash: API, Pricing, Effort Levels and Limits
MiniMax M3.1 Flash explained: $0.15/$0.60 pricing, 1M context, always-on thinking, five effort levels, vendor benchmarks, and what our live API runs showed.
The first thing that broke when we pointed a test script at MiniMax M3.1 Flash was not the model. It was a habit: sending reasoning_effort: "none" to get a fast, cheap answer. M3.1 Flash rejects that with HTTP 400. Thinking is always on, and the only lever you get is how much of it you pay for.
MiniMax M3.1 Flash is MiniMax’s new low-cost tier of the M3 line, released on October 19, 2026. It is a text-output model for coding, tool use and agent workflows, with a 1M-token context window and a flat price of $0.15 per million input tokens and $0.60 per million output tokens. This guide is for developers deciding whether to route agent or coding traffic to it. It covers what MiniMax has confirmed, what is still only reported, how the five effort levels behaved in our own calls on October 21, and where the model is weaker than its price suggests.
MiniMax M3.1 Flash: Key takeaway
- MiniMax lists M3.1 Flash at $0.15 input, $0.60 output and $0.015 cached input per 1M tokens, with no long-context tier. That is half of MiniMax M3’s current (already discounted) rate.
- Thinking cannot be disabled. Effort accepts
low,medium,high,xhighandmax; omitting it meansmax. - In our 18 code-fix calls through SandBase, every effort level passed the unit checks.
lowused 93–132 completion tokens;maxranged from 233 to 1,605. - MiniMax’s own table puts it first on Automation-Bench v1.0.6 (62.2) but well behind Opus 5 on Terminal Bench 4.0 (38.1 vs 51.8). All of these scores are vendor-reported.
- MiniMax says the weights will be released “later”. As of October 21, no M3.1 Flash repository appears under MiniMaxAI on Hugging Face, and no license has been published.
What MiniMax actually released
MiniMax’s launch post is short on architecture and long on positioning. It says M3.1 Flash improves agentic tasks, coding, computer use and cybersecurity, runs online inference “nearly three times faster”, and cuts overall usage cost for agentic tasks by 70% versus its predecessor. It also confirms that Space Bunny, an anonymous model that processed more than 200 trillion tokens, was an early M3.1 Flash build.
The model invocation guide is where the operational facts live. It lists MiniMax-M3.1-Flash with a 1,000,000-token context window and describes it as “an ultra-efficient open-weight model for everyday work”. The same guide documents the effort field and the inability to turn thinking off.
Some details circulating in coverage are not on a MiniMax page we could load. SiliconANGLE cites 428B total parameters, saying size barely changed from M3. MarkTechPost adds about 23B active parameters and gives October 23 as the weights date. Treat both as reported, not confirmed. The launch post itself only says weights “will be released later”, and that a larger Pro model is coming.
| Item | Status on 2026-10-21 | Source |
|---|---|---|
| Release date | October 19, 2026 | MiniMax launch post |
| API model ID | MiniMax-M3.1-Flash | MiniMax invocation guide |
| Context window | 1,000,000 tokens | MiniMax invocation guide |
| Output | Text, with a separate reasoning stream | MiniMax invocation guide |
| Image input | Supported; we tested it | SandBase listing, our run |
| Video input | Claimed in press coverage; not tested by us | SiliconANGLE, MarkTechPost |
| Parameters | 428B total (reported); ~23B active (reported) | SiliconANGLE; MarkTechPost |
| Weights and license | ”Later”; no license published | MiniMax launch post, Hugging Face check |
| Where to call it | MiniMax API, M Plan, MiniMax Code; also SandBase | MiniMax launch post, SandBase model page |
On SandBase the model is listed as minimax/minimax-m3.1-flash on the OpenAI-compatible Chat Completions endpoint. The page shows a 512K maximum output and supports vision, reasoning, function calling and structured output. That is SandBase routing access to MiniMax’s model, not a separate SandBase build.
SandBase model page for minimax/minimax-m3.1-flash, captured 2026-10-21: input and output prices match MiniMax’s list, with a 1M context and 512K maximum output.
One inconsistency is worth flagging before you build on it. The SandBase description mentions text, image and video input, while its own spec table lists text and image. We only verified image input. If video understanding matters to you, test it on your route before relying on it.
Always-on thinking and the five effort levels
This is the change that will hit existing integrations first. MiniMax’s guide states that thinking “cannot be turned off”. Sending thinking: {"type": "disabled"} or effort: "none" returns a 400 error. On the OpenAI-compatible protocol the reasoning comes back in reasoning_content and the answer in content, so you no longer parse <think> tags out of the response.
The effort field name depends on the protocol:
| Protocol | Effort field | Where reasoning is returned |
|---|---|---|
| Anthropic-compatible (MiniMax’s recommended path) | output_config.effort | thinking content block |
| OpenAI Chat Completions | reasoning_effort | reasoning_content field |
| OpenAI Responses | reasoning.effort | type: "reasoning" output item |
MiniMax invocation guide, captured 2026-10-21: effort field names per protocol, and the Limitations note that disabling thinking returns 400.
Here is the part we wanted to measure rather than assume. “Lower effort means fewer tokens” is the obvious reading, but it says nothing about how variable each level is. So we sent the same small bug-fix prompt (a median() function with an off-by-one error) three times at each level through SandBase on October 21, and checked every returned function against four unit tests.
Our effort probe, 2026-10-21, rendered from the raw JSONL log: 18 successful calls, all passing; effort: "none" returned HTTP 400 through SandBase as well.
Three things stood out:
- Every level solved this task. That is a statement about one easy prompt, not about hard coding work. It does show that
lowis not a broken mode. lowwas tight;maxwas not. Low produced 93–132 completion tokens. Max produced 233 on one run and 1,605 on another, on the identical prompt. If you budget by average, max will surprise you on the tail.- Omitting effort behaved like a high setting, at 197–740 tokens. That is consistent with MiniMax’s documented default of
max. If you migrate from a model whose default is cheap, you will inherit the most expensive level without noticing.
Latency in this small sample was noisy, from 3.7 to 16.9 seconds, and does not support a per-level speed ranking. MiniMax’s own speed claim is 200+ tokens per second in everyday use, with a P50 of 170+. We did not measure throughput, so we cannot confirm or refute it.
Scope of this test: one prompt, three runs per level, one day, one route. It tells you the shape of the token distribution, not the quality ceiling.
Pricing: what $0.15 / $0.60 means per task
MiniMax’s pricing page lists one flat row for M3.1 Flash. M3 has two tiers split at 512K input tokens, both shown as a “Permanent 50% off” from struck-through prices of $0.60 / $2.40 and $1.20 / $4.80, plus a Priority tier at 1.5×.
| Model (MiniMax current price, per 1M tokens) | Input | Output | Cache read |
|---|---|---|---|
| MiniMax-M3.1-Flash | $0.15 | $0.60 | $0.015 |
| MiniMax-M3, ≤512K input | $0.30 | $1.20 | $0.06 |
| MiniMax-M3, >512K input | $0.60 | $2.40 | $0.12 |
MiniMax launch post, captured 2026-10-21: flat pricing of $0.15 input, $0.60 output and $0.015 cached input per 1M tokens.
Per token, Flash is half of M3’s current discounted rate, and a quarter of M3’s current rate above 512K input. MiniMax’s “70% lower” figure is about overall cost on agentic tasks, which also depends on how many tokens each task burns. MiniMax has not published the calculation behind that number.
Our runs make the token side concrete. One code-fix call at low cost about $0.0001. The worst max run cost about $0.0010, ten times more for the same answer. At a million such calls a month, that gap is roughly $100 versus $1,000 before retries. The cheapest lever is not a different model. It is setting effort explicitly per route.
One more observation from the logs. A one-sentence prompt (“Which is bigger, 9.11 or 9.9? One sentence.”) came back as 219 prompt tokens on the SandBase route in three separate calls, and our short code-fix prompt as 278. The same code-fix prompt on DeepSeek V4.1 Flash counted 106. Some fixed overhead is being added before the model sees your text. At $0.15 per million it is cheap, but it means per-call input cost has a floor of roughly $0.00003. We have not identified where the overhead comes from.
SandBase lists the same $0.15 / $0.60 input and output rates as MiniMax. Check cached-input billing against your own usage records rather than assuming it matches MiniMax’s $0.015.
Benchmarks: strong on office agents, weaker on terminals
MiniMax published a 15-benchmark table comparing M3.1 Flash with DeepSeek V4.1 Flash, Kimi K3, GLM-5.3, GPT-5.6 Sol and Opus 5. Every number in it is MiniMax-reported, with harness notes per benchmark.
MiniMax’s comparison table from the launch post (vendor-reported, harness notes omitted in this crop). The highlighted column is M3.1 Flash.
| Benchmark (MiniMax-reported) | M3.1 Flash | Opus 5 | DeepSeek V4.1 Flash 1017 |
|---|---|---|---|
| Automation-Bench v1.0.6 | 62.2 | 50.3 | 60.5 |
| BankerToolBench | 76.2 | 76.2 | – |
| OSWorld 2.0 | 61.7 | 70.6 | – |
| DeepSWE v1.1 | 73.7 | 74.0 | 77.0 |
| Terminal Bench 4.0 | 38.1 | 51.8 | 42.3 |
| NL2Repo-Bench | 61.2 | 75.3 | 68.2 |
| CyberGym | 82.2 | – | – |
| HLE (no tools, text subset) | 43.4 | 55.6 | 42.6* |
*DeepSeek’s own change log lists 42.6 for HLE without tools and 44.0 on the text-only subset, so this cell is probably not on the same subset as MiniMax’s row.
The pattern is consistent. M3.1 Flash is closest to frontier models on structured business-workflow agents: Automation-Bench, BankerToolBench, long-context LOCA-Bench. It drops back on open-ended repository and terminal work: on Terminal Bench 4.0 it scores 38.1 to Opus 5’s 51.8, and on NL2Repo 61.2 to 75.3. In MiniMax’s own table, DeepSeek’s newer Flash checkpoint also beats it on DeepSWE, Terminal Bench 4.0 and NL2Repo. We compare the two directly in MiniMax M3.1 Flash vs DeepSeek V4.1 Flash.
Two caveats. First, MiniMax’s cost chart plots Automation-Bench at 62.8 for max effort while the table says 62.2, so small differences are inside the noise of the vendor’s own reporting. Second, independent data is thin. The Artificial Analysis snapshot SandBase keeps (Intelligence Index v4.3, data fetched 2026-10-19) does not yet include M3.1 Flash. It scores AA’s “MiniMax-M3” entry at 29.2, so any independent figure for Flash should be read against that baseline. The index is one composite measure; see its methodology. VentureBeat headlines a high hallucination rate for the model; we could not load the article to check the detail. For extraction or fact-heavy work, add a verification step.
When M3.1 Flash is a good fit
| Workload | Fit | Why |
|---|---|---|
| High-volume tool-calling agents (CRM, ticketing, finance ops) | Strong | Best vendor-reported scores sit here; tool calls in our runs were fast and correct |
| Routine coding fixes and code review comments | Good | Low effort solved our task at about $0.0001 per call |
| Long-context reading up to 1M tokens | Good | Flat price with no >512K surcharge, unlike M3 |
| Hard repo-scale or terminal agents | Weaker | Trails Opus 5 and DeepSeek V4.1 Flash 1017 on Terminal Bench and NL2Repo |
| Latency-critical chat with tiny prompts | Mixed | Thinking cannot be disabled, so there is always a reasoning floor |
| Self-hosting today | Not yet | No weights or license published as of October 21 |
The useful mental model: M3.1 Flash is a cheap, competent default for agents that call tools in well-defined business systems. It is not a quiet replacement for your hardest coding model. For a different flash-tier option with published open weights, see our GLM-5.3-Flash pricing analysis.
How to call it
Through MiniMax directly, use https://api.minimax.io/v1 (OpenAI-compatible) or https://api.minimax.io/anthropic with model MiniMax-M3.1-Flash. Through SandBase, use the model ID minimax/minimax-m3.1-flash on /v1/chat/completions; the model page has the exact request and a playground. Either way, set effort explicitly:
curl https://api.sandbase.ai/v1/chat/completions \
-H "Authorization: Bearer $SANDBASE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "minimax/minimax-m3.1-flash",
"reasoning_effort": "low",
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Fix the off-by-one bug in this function: ..."}]
}'Before you switch production traffic, run a short checklist. Remove any effort: "none" or disabled-thinking flags. Stop parsing <think> tags and read reasoning_content instead. Pick an effort per route. Keep the full assistant message in multi-turn tool conversations, because MiniMax’s API docs say the reasoning chain depends on it.
FAQ
How much does MiniMax M3.1 Flash cost?
MiniMax lists $0.15 per 1M input tokens, $0.60 per 1M output tokens and $0.015 per 1M cached input tokens, with no long-context tier (checked October 21, 2026). SandBase lists the same input and output rates.
Can I turn off thinking in MiniMax M3.1 Flash?
No. Disabled thinking or effort: "none" returns HTTP 400, both on MiniMax’s API per its docs and through SandBase in our test. Use reasoning_effort: "low" to cut reasoning tokens.
Is MiniMax M3.1 Flash open-weight?
MiniMax calls it open-weight and says weights will be released later. As of October 21, 2026, there is no M3.1 Flash repository under MiniMaxAI on Hugging Face and no published license. Do not plan a self-hosted rollout until both exist.
What is the context window?
1,000,000 tokens per MiniMax’s guide. SandBase lists a 512K maximum output.
Is M3.1 Flash better than MiniMax M3?
On MiniMax’s own claims it is faster and cheaper per task, and it costs half as much per token as M3’s current rate. Artificial Analysis had not published a v4.3 score for Flash in the 2026-10-19 snapshot, so a like-for-like independent comparison is not available yet. In our small run, M3.1 Flash had a lower median latency than M3 on the tool-call and invoice tasks (2.5 s vs 12.2 s, 3.3 s vs 13.1 s). On the code-fix task at default effort, M3 was slightly faster.
M3.1 Flash makes the most sense as a high-volume agent model where you control effort per route. The price is real and the documented limits are clear. The benchmarks are still MiniMax’s own, so test it on your own workflow before it carries production traffic.