MiniMax-M3 is hosted in the European Union
MiniMax-M3 is EU-hosted on our serverless inference. Each model has its own processing region, and the MiniMax-M3 model page lists M3's as "EU-hosted".
Can you run MiniMax-M3 with processing in Europe, and what happens to a setup built on M2.5? Both questions come up when a security review asks where prompts go. They also come up when a model you relied on disappears from a catalogue.
Lyceum is a sovereign European AI inference provider for open-source models. Our serverless models run in Paris and Finland. We don't keep your prompts or outputs, and we never use them for training.
MiniMax built M3 for long coding and office tasks. Its model card describes a native multimodal model: it was trained from the start to read images as well as text. It has about 428 billion parameters, of which about 23 billion are active per token. That design is a mixture of experts (MoE): the model holds many expert sub-networks and uses only a few for each token. M3 also introduces MiniMax Sparse Attention, which reads only selected blocks of the earlier text instead of all of it. In its launch post, MiniMax reports 59.0% on SWE-Bench Pro, a test built from real software issues. That is the vendor's own figure, not a measurement of ours.
Open models are now close to the frontier. Since January 2026, the best open-weight models have trailed the best closed ones by about four months on average. Epoch AI measured it from 1 January to 28 May 2026. So a European team no longer needs a US API to get quality close to the best closed models.
MiniMax-M2.5 is retired: what changes if you used it
We retired MiniMax-M2.5 on 5 October 2026, and its model page now forwards to MiniMax-M3. The models page lists M3 as the MiniMax model we serve.
If your code called M2.5, two things change when you move to M3:
- The model string becomes `minimax/minimax-m3`. Nothing else in an OpenAI-compatible client has to change.
- Reasoning is always on. M3 accepts a setting to switch it off, but ignores it.
M3 reads up to 1M tokens in one request. That limit is its context window (the amount of text the model reads at once).
Re-price the workload at M3's rates from its model page. Do not carry over a budget built on older prices.
What MiniMax-M3 costs per million tokens
MiniMax-M3 is billed per token, in US dollars, with no base fee. These are the rates and limits on its model page, read on 23 October 2026.
| Item | MiniMax-M3 on our serverless inference |
|---|---|
| Model ID | minimax/minimax-m3 |
| Input | $0.40 per 1M tokens |
| Cached input | $0.10 per 1M tokens |
| Output | $2.00 per 1M tokens |
| Context window | 1M tokens |
| Longest answer per request | 131,072 output tokens, up to 300 seconds |
| Input types | Text and images in, text out |
Cached input means a prompt start that matches a recent request and is still in GPU memory. That part bills at $0.10 instead of $0.40. Caching is automatic but best effort, so a hit is likely, not guaranteed.
The speed figures below come from our own status checks (23 October 2026). Over the seven days to 23 October 2026, M3 returned its first token in a median 557 ms on short requests. It then wrote about 86 tokens per second. At that speed, the 300-second limit holds about 25,800 tokens (300 × 86). So in practice the time limit ends a long answer well before the 131,072-token cap. Live figures and incidents are on our status page.
Long prompts take longer to start. The model keeps a record of every token it has read, the KV cache (key-value cache). The authors of vLLM, an open-source serving engine, found it is large for each request and grows with every token. The 557 ms median covers short requests only, so measure the first-token time on your own prompt lengths. Our guide to context length and GPU memory explains the sizing.
A worked example: one month of document review
Take a hypothetical team that reviews 1,000 contracts a day with MiniMax-M3, for 30 days. Each request sends 30,000 input tokens: 6,000 tokens of fixed instructions and 24,000 tokens of new contract text. Each answer is 2,000 output tokens, reasoning included.
Each request costs the sum of three parts:
cost per request = (new input tokens × $0.40 + cached input tokens × $0.10 + output tokens × $2.00) / 1,000,000| Calculated example, hypothetical inputs, prices of 23 October 2026 | Per request | Per month (30,000 requests) |
|---|---|---|
| No cache hits: all 30,000 input tokens billed as new | $0.0160 | $480 |
| The 6,000 instruction tokens hit the cache | $0.0142 | $426 |
| Cache hits, but answers grow to 4,000 output tokens | $0.0182 | $546 |
In the first row, input costs $0.012 and output $0.004. Output is 6.25% of the tokens but 25% of the bill. The cache saves $54 a month, or 11.25%.
The third row shows the bigger lever. Reasoning always runs, and its trace bills as output. If answers double to 4,000 tokens, the month costs $120 more than the cached row. We recommend pricing M3 on your output tokens first. Set `max_tokens` high enough for reasoning plus answer, and ask for short answers.
The example favours caching: it assumes every request finds its instructions in memory. It does not show image input, longer contracts or a real hit rate. Your own usage numbers will differ.
Why a family name is not a region
A model's processing region belongs to that one model, not to its family. Our M3 model page says it plainly: "Check the model's processing region before sending data."
A model card does not settle it either. Hugging Face says a model card should describe the model, its intended uses and limits, its training and its evaluation results. Where an API runs that model is a property of the provider, so read it on the provider's model page.
Routing aliases add one more layer. Our alias lyceum/complex sends each request to MiniMax-M3 today and bills it as M3. An alias is not a model and carries no region of its own. If your compliance review names a model, call that model's ID directly.
Calling MiniMax-M3 through the OpenAI-compatible API
You call MiniMax-M3 through one OpenAI-compatible API, the same one we use for every model on our serverless inference. The official OpenAI Python library takes a `base_url`, so pointing it at another endpoint is one setting. The base URL in the code below is the one on our model page, and your Lyceum dashboard shows the same one. Add your Lyceum API key.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["LYCEUM_API_KEY"],
base_url="https://api.lyceum.technology/openai/v1",
)
resp = client.chat.completions.create(
model="minimax/minimax-m3",
max_tokens=4000, # room for the reasoning trace plus the answer
messages=[
{"role": "system", "content": "Review the contract. List the termination clauses."},
{"role": "user", "content": "<contract text>"},
],
)
print(resp.choices[0].message.content)
details = resp.usage.prompt_tokens_details
print(resp.usage.prompt_tokens, getattr(details, "cached_tokens", None))The last line prints how many input tokens came from the cache. The `cached_tokens` field is missing on a miss. Tool calling works in the standard OpenAI format, including `tool_choice: "required"`. Our tests of open models with reliable function calling cover how to check it on your own tools.
MiniMax publishes M3's weights under the MiniMax Community License. It sets conditions for commercial use, including use through hosted APIs. Read it with your legal team before you build a paid product on M3.
If your workload needs EU processing and MiniMax quality, open the MiniMax-M3 model page, check the region and price, then change the model string.