MiniMax M3.1 Flash API Guide (2026): $0.15 Pricing, 1M Context, and How to Call It

On October 19, 2026, MiniMax rolled out MiniMax-M3.1-Flash, a 1M-context model priced at $0.15 per million input tokens and $0.60 per million output tokens. That's the same sticker price as DeepSeek's off-peak Flash rate, except MiniMax calls its pricing flat. No peak-hour multiplier. If you run agent loops or batch coding jobs, that's worth ten minutes of your time.

MiniMax says an anonymous early build, nicknamed Space Bunny, processed more than 200 trillion tokens before launch. It also claims nearly three times faster inference and 70% lower cost on agentic tasks than its predecessor. Those are vendor numbers and I haven't reproduced them. Prices and API details below come from MiniMax's launch post and platform docs, checked on October 21, 2026.

What MiniMax Actually Shipped

M3.1 Flash is the Flash-tier release in MiniMax's M3 line. MiniMax positions it for agentic work, coding, computer use, and cybersecurity, and says a bigger "Pro" model arrives later. The launch post also says model weights will be released later, with no date attached.

The headline benchmark claims, all reported by MiniMax itself: 73.7% on DeepSWE v1.1 for real-world coding, 61.7 on OSWorld V2 for computer use, 29.6 on Agents' Last Exam, 82% on CyberGym, and 76.2 on BankerToolBench. MiniMax also quotes output speeds above 200 tokens per second. Treat all of that as a reason to run your own evals, not to skip them.

MiniMax M3.1 Flash Pricing (USD per 1M Tokens)

All figures below are US dollars per 1 million tokens, taken from MiniMax's pay-as-you-go pricing page on October 21, 2026. The older MiniMax-M3 stays available and uses length-based tiers; M3.1 Flash drops them.

Quick math. A request with 100,000 input tokens and 10,000 output tokens costs $0.015 for input plus $0.006 for output, so $0.021. An agent step with 50,000 input tokens (90% cache hits) and 5,000 output tokens costs $0.000675 for cached input, $0.00075 for fresh input, and $0.003 for output: about $0.0044. I found no separate cache-write fee on the pricing page.

How to Call It: curl, Python, Node.js

MiniMax accepts both Anthropic-style and OpenAI-style requests. The docs call the Anthropic path the recommended one because it supports thinking blocks and interleaved thinking. These examples mirror MiniMax's documented calls; I haven't run them against a live key, so test with a small prompt first.

curl https://api.minimax.io/anthropic/v1/messages \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMax-M3.1-Flash",
    "output_config": {"effort": "medium"},
    "max_tokens": 4096,
    "messages": [
      {"role": "user", "content": "Explain this stack trace in two sentences."}
    ]
  }'

The OpenAI-compatible route works with the stock OpenAI SDK. Only the base URL, key, and model name change:

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.1-Flash",
    reasoning_effort="medium",
    max_completion_tokens=4096,
    messages=[
        {"role": "system", "content": "You are a careful code reviewer."},
        {"role": "user", "content": "Find the bug: def avg(xs): return sum(xs) / len(xs) + 1"},
    ],
)

msg = resp.choices[0].message
print("thinking:", getattr(msg, "reasoning_content", None))
print("answer:", msg.content)
print("usage:", resp.usage)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://api.minimax.io/anthropic",
  apiKey: process.env.MINIMAX_API_KEY,
});

const message = await client.messages.create({
  model: "MiniMax-M3.1-Flash",
  output_config: { effort: "medium" },
  max_tokens: 4096,
  messages: [{ role: "user", content: "Summarize this diff in three bullets." }],
});

for (const block of message.content) {
  if (block.type === "thinking") console.log("thinking:", block.thinking);
  if (block.type === "text") console.log(block.text);
}

Gotchas from the docs

• Effort defaults to max. Accepted values are low, medium, high, xhigh, and max. The field is output_config.effort on the Anthropic path and reasoning_effort on the OpenAI path. Higher effort means more output tokens, and output is the pricey half of the bill.
• You can't turn thinking off. M3.1 Flash always thinks, and sending a disabled thinking type returns a 400.
• Thinking eats your token cap. If max_tokens is too small, you get finish_reason: "length" and an empty answer. Give it room.
• Sampling knobs are ignored on the OpenAI-compatible route. temperature, top_p, and the penalty parameters do nothing there. n only supports 1, and audio input isn't supported.
• Multi-turn tool calls need the full assistant message. Append the whole response, including the tool_calls field, to history or the reasoning chain breaks.

M3.1 Flash vs DeepSeek Flash vs Sonnet 5.5 vs GPT-6.1 Sol

The last column prices one identical workload at list price: 100M input tokens (all cache misses) and 20M output tokens. Competitor figures come from our earlier posts on DeepSeek Flash, Claude Sonnet 5.5, and GPT-6.1 Sol, each sourced from the vendor's own docs.

The interesting matchup is MiniMax against DeepSeek, not against the frontier models. Same sticker price. The differences are in the fine print. DeepSeek's cache-hit input is $0.003 per 1M tokens off-peak, five times cheaper than MiniMax's $0.015. Run that 50,000-input, 90%-cached, 5,000-output agent step on DeepSeek off-peak and it costs about $0.0039, slightly under MiniMax's $0.0044. At DeepSeek's peak rates the same step costs about $0.0078, which is roughly 75% more than MiniMax. So cache-heavy loops that you can schedule off-peak favor DeepSeek. Anything that has to run on a weekday morning UTC favors MiniMax's flat rate.

Against Sonnet 5.5, the same agent step costs about $0.069 with its $0.20 cache-read rate (cache writes excluded), roughly 16 times more. That gap pays for a lot of retries, but a model that needs three attempts to land a fix still costs more than one that nails it first time. Only your evals can say which you've got.

Where I'd Use It, and Where I Wouldn't

I'd use it for agent loops with a long, stable prefix, bulk triage or review jobs that run around the clock, and the first-pass tier of a two-model router with a stronger model behind it. I'd skip it for anything needing sampling control on the OpenAI-compatible route, multiple completions per request, or audio input. And if self-hosting is on your roadmap, don't plan around the weights. MiniMax gave no date.

Checklist Before You Move Traffic

1. Set effort explicitly. Start at medium and move up only where evals show a gap.
2. Raise your token cap. Thinking tokens count toward it.
3. Keep prompt prefixes byte-identical so cache hits land at $0.015 instead of $0.15.
4. Check concurrency limits. I didn't verify them for this model.
5. Price your real volumes in the API cost calculator and measure prompts with the token counter.

Most production stacks end up mixed: a cheap model for the bulk of traffic, a stronger one for the hard 10%. For the Claude and GPT side of that setup, KissAPI gives you one OpenAI-compatible endpoint and one key, so you aren't juggling a separate dashboard per provider.

Frequently Asked Questions

How much does the MiniMax M3.1 Flash API cost?

MiniMax-M3.1-Flash costs $0.15 per 1M input tokens, $0.60 per 1M output tokens, and $0.015 per 1M cached input tokens. MiniMax describes the pricing as flat, so the rate does not change with prompt length or time of day. A request with 100,000 input tokens and 10,000 output tokens costs about $0.021.

What is the MiniMax M3.1 Flash model name, context window, and base URL?

The API model name is MiniMax-M3.1-Flash and the context window is 1,000,000 tokens. The Anthropic-compatible base URL is https://api.minimax.io/anthropic, which MiniMax recommends, and the OpenAI-compatible base URL is https://api.minimax.io/v1.

Can you turn off thinking in MiniMax M3.1 Flash?

No. MiniMax-M3.1-Flash always thinks, and sending a thinking type of disabled returns a 400 error. You control depth with the effort setting instead, which accepts low, medium, high, xhigh, and max. When effort is omitted it defaults to max, which produces the most output tokens.