MiniMax M3.1 Flash Now Free on OpenRouter: A 1M-Context Coding Powerhouse

MiniMax M3.1 Flash recently appeared on OpenRouter as a free offering, and for developers this is a noteworthy change. Previously, this model was largely confined to MiniMax's own toolchain, but now anyone with an API key can call it with just a few lines of code.

From Closed Preview to Open Access

MiniMax quietly released a preview of M3.1 Flash on September 27 with virtually no promotion. It first appeared in MiniMax Code, and for the following weeks the only way to use it was through MiniMax Code or a MiniMax Token Plan^Ad subscription. There was no pay-as-you-go pricing, no public weights, and no independent benchmarks.

Now the free listing on OpenRouter changes that—with a single API key, you can integrate and test it in minutes.

Model Positioning and Core Specs

According to public information, M3.1 Flash is a lightweight version of MiniMax M3. M3 is MiniMax's flagship model launched in June, built on MiniMax Sparse Attention, which makes running a 1 million token context far cheaper than the previous generation. Flash inherits the same 1 million context window.

It is positioned for everyday coding tasks: fixing bugs, implementing small features, iterating on development—not for solving the hardest problems.

Input supports text, images, and video; output is text, with support for tool calling and agentic workflows.

Architecturally it uses MoE (Mixture of Experts), reportedly with about 428B total parameters and about 23B activated per token—which is precisely why it can be called "Flash".

MoE (Mixture of Experts) architecture: A mixture-of-experts model consists of multiple "expert" subnetworks, and a routing mechanism activates only a few of them per token rather than invoking all parameters. This allows the total parameter count to be very large (e.g., 428B) while the number of activated parameters in a single forward pass remains small (about 23B), thereby significantly reducing inference cost and latency while retaining large-model capacity. This is also a common design approach for "Flash"-style lightweight models, in contrast to dense models where "total parameters equal activated parameters".

MiniMax Sparse Attention: Sparse attention is the key technique for reducing long-context costs. Standard attention grows quadratically with sequence length, whereas sparse attention lets each token attend to only some positions (such as a local window plus a small number of global tokens), bringing compute down to nearly linear. This is why running a 1 million token context costs far less than the previous generation of models, and it makes a 1M window more feasible in engineering terms.

Thinking Can't Be Turned Off, but Its Intensity Can Be Tuned

A key difference between M3.1 Flash and M3: M3 allows reasoning to be disabled, while M3.1 Flash does not. Thinking is always on, and users can only choose the reasoning effort: low, medium, high, xhigh, max, with max as the default. Attempting to disable thinking returns an error.

For a model aimed at everyday coding, this design is a reasonable trade-off. What you get is a knob rather than a switch—use low for quick edits and max for complex refactoring, with no need to switch models.

Reasoning effort is a type of parameter that controls how many "thinking tokens" a model allocates before generating an answer. The higher the effort, the more the model tends to expand intermediate reasoning steps and self-check, usually yielding better quality but slower and more expensive responses; lower effort means faster responses. A common implementation maps the level to a thinking budget or prompting strategy. This is a different dimension from "whether thinking is enabled": M3 offers a switch, while M3.1 Flash retains only the effort knob and forces thinking to always be on.

Speed and Observed Performance

MiniMax has not yet published official speed data. Early users report decoding speeds in the range of 90–110 tokens/second, but this is only anecdotal and needs to be verified by formal benchmarks.

How to Try It

OpenRouter is compatible with the OpenAI API—just replace the base URL:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="YOUR_OPENROUTER_KEY",
)

resp = client.chat.completions.create(
    model="minimax/minimax-m3.1-flash:free",
    messages=[{"role": "user", "content": "Find the bug in this function: ..."}],
)
print(resp.choices[0].message.content)

Note that OpenRouter's free tier typically has rate limits, making it suitable for trying things out rather than for production environments.

OpenRouter is a multi-model API aggregation gateway that forwards requests to models from different vendors through a unified interface and routes them by model identifier (such as minimax/minimax-m3.1-flash:free). It is compatible with OpenAI's Chat Completions protocol, so you only need to replace the base_url and api_key, and existing OpenAI SDK code can call it with almost no changes. The :free suffix indicates a free variant, which usually comes with rate limits and availability fluctuations and is not suitable for production workloads.

Why It's Worth Watching

A coding model with a 1 million context, multimodal input, and reasoning capabilities, offered at $0, means a considerable amount of capability can be explored freely. If it performs reliably on real codebases, it is a strong free option for agents and coding assistants; if it underperforms, the cost of trying is zero.

According to observations from DEV·TV's NEW MODELS channel, the next thing to watch is DeepSeek^Ad V4.1 Flash—"Flash" models have been quite active this week.

One-line Summary

MiniMax M3.1 Flash is now free on OpenRouter—a coding model with 1M context and adjustable reasoning effort, open for anyone to call.

Paragraph Summary

Previously available only in preview within MiniMax's own toolchain, MiniMax M3.1 Flash has now landed on OpenRouter as a free offering, letting any developer with an API key integrate it in just a few lines of code. It is a lightweight version of the flagship M3, inheriting a 1 million token context and multimodal input, and uses an MoE architecture (about 428B total parameters, 23B activated), positioned for everyday coding tasks. Unlike M3, thinking cannot be disabled—only adjusted via five effort levels from low to max, with max as the default. Early users report decoding speeds of about 90–110 tokens/second, but there are no official benchmarks yet. OpenRouter's free tier has rate limits, making it suitable for trying out and evaluating rather than for production.