Unlock exclusive introductory pricing for the newly launched Gemini 3.5 Flash.
M

MiniMax M2.1

ฤแบงu vร o:$0.24/M
ฤแบงu ra:$0.96/M
Bแป‘i cแบฃnh:204,800(total input + output per request)
ฤแบงu ra tแป‘i ฤ‘a:131.1K
Ngร y phรกt hร nh:Oct 1, 2025

MiniMax M2.1: Significantly Enhanced Multi-Language Programming, Built for Real-World Complex Tasks

Mแป›i
Sแปญ dแปฅng thฦฐฦกng mแบกi

Playground cho MiniMax M2.1

Khรกm phรก Playground cแปงa MiniMax M2.1 โ€” mรดi trฦฐแปng tฦฐฦกng tรกc ฤ‘แปƒ kiแปƒm tra mรด hรฌnh vร  chแบกy truy vแบฅn theo thแปi gian thแปฑc. Thแปญ prompts, ฤ‘iแปu chแป‰nh tham sแป‘ vร  lแบทp lแบกi ngay lแบญp tแปฉc ฤ‘แปƒ tฤƒng tแป‘c phรกt triแปƒn vร  xรกc thแปฑc cรกc trฦฐแปng hแปฃp sแปญ dแปฅng.

What is MiniMax M2.1

MiniMax M2.1 is the follow-up release to the MiniMax M2 family, published by MiniMax on Dec 23, 2025. It is positioned as an open-source, production-oriented model designed specifically for coding, agentic multi-step workflows (tool use, multi-turn planning), and full-stack app generation (web, mobile, backend). The release emphasizes improved multi-language programming, better mobile / native app capabilities, concise responses, and improved tool/agent generalization.

Main features

  • MoE efficiency: Large total parameter count but only a small active subset per token (architecture designed to trade peak capacity for inference efficiency).
  • Coding-first optimizations: Strong polyglot code comprehension and generation across many languages (Python, TypeScript, Rust, Go, C++, Java, Swift, mobile native languages).
  • Agentic & tool workflows: Designed for tool calls, multi-step plans, and โ€œinterleaved thinkingโ€ / chained execution of composite instruction constraints.
  • Large context support & long outputs: Targeted at long-context developer workflows and agent trace/history.
  • Low-latency / high-throughput: Practical for interactive coding assistants and scaled agent loops due to the selective-activation design and deployment optimizations.

Technical capabilities and specifications

  • Architecture: Mixture-of-Experts (MoE) design.
  • Parameters: Reported design: ~230 billion total parameters with ~10 billion active parameters used per inference (MoE active subset). This is the same active-parameter efficiency model used in the M2 family.
  • Inference characteristics: Designed for low-latency interactive use, high-throughput batched inference, and agentic loops with frequent tool calls.
  • Streaming / function calling: supports streaming token output and advanced function-call/tool interfaces for structured I/O.

Benchmark performance

MiniMax released comparative benchmark claims and third-party aggregators reported scores at launch; representative published figures include:

Multi-SWE Bench / SWE-Bench (coding/agentic suites): provider and aggregator listings cite 49.4% on Multi-SWE-Bench and 72.5% on SWE-Bench Multilingual for M2.1 (these are scoring aggregates for code-generation and code reasoning tasks).

M2.1 shows comprehensive improvements over M2 in test case generation, code optimization, code review and instruction following and M2.1 outperforms M2 and often matches or surpasses Claude Sonnet 4.5 on several coding subtasks.

MiniMax M2.1

Representative production use cases

  1. IDE code assistant & refactoring: Multi-file refactors, code review suggestions, automated test generation and patch generation across multiple languages.
  2. Agentic โ€œDigital Employeeโ€: Automating repetitive office workflows (searching ticket systems, summarizing documents, interacting with web apps through text-based commands) using tool integration and interleaved thinking.
  3. Multi-language engineering support: Teams that maintain polyglot codebases (Rust, Go, Java, C++, TypeScript) can use M2.1 for cross-language code synthesis and conversions.
  4. Automated code evaluation & test generation: Generating testcases, running code analysis and producing suggested fixes or optimizations as part of CI tooling.
  5. Local/on-prem research and customization: Organizations that require on-prem control can fine-tune or run M2.1 locally using published weights and recommended inference stacks.

How to access and use MiniMax M2.1 API

Step 1: Sign Up for API Key

Log in to cometapi.com. If you are not our user yet, please register first. Sign into your CometAPI console. Get the access credential API key of the interface. Click โ€œAdd Tokenโ€ at the API token in the personal center, get the token key: sk-xxxxx and submit.

Step 2: Send Requests to MiniMax M2.1 API

Select the โ€œminimax-m2.1โ€ endpoint to send the API request and set the request body. The request method and request body are obtained from our website API doc. Our website also provides Apifox test for your convenience. Replace <YOUR_API_KEY> with your actual CometAPI key from your account. Where to call it: Chat-style APIs.

Insert your question or request into the content fieldโ€”this is what the model will respond to . Process the API response to get the generated answer.

Step 3: Retrieve and Verify Results

Process the API response to get the generated answer. After processing, the API responds with the task status and output data.

Cรขu Hแปi Thฦฐแปng Gแบทp

Giรก cแบฃ cho MiniMax M2.1

Khรกm phรก mแปฉc giรก cแบกnh tranh cho MiniMax M2.1, ฤ‘ฦฐแปฃc thiแบฟt kแบฟ ฤ‘แปƒ phรน hแปฃp vแป›i nhiแปu ngรขn sรกch vร  nhu cแบงu sแปญ dแปฅng khรกc nhau. Cรกc gรณi linh hoแบกt cแปงa chรบng tรดi ฤ‘แบฃm bแบฃo bแบกn chแป‰ trแบฃ tiแปn cho nhแปฏng gรฌ bแบกn sแปญ dแปฅng, giรบp dแป… dร ng mแปŸ rแป™ng quy mรด khi yรชu cแบงu cแปงa bแบกn tฤƒng lรชn. Khรกm phรก cรกch MiniMax M2.1 cรณ thแปƒ nรขng cao cรกc dแปฑ รกn cแปงa bแบกn trong khi vแบซn kiแปƒm soรกt ฤ‘ฦฐแปฃc chi phรญ.

Comet Price (USD / M Tokens)Official Price (USD / M Tokens)Discount
ฤแบงu vร o:$0.24/M
ฤแบงu ra:$0.96/M
ฤแบงu vร o:$0.3/M
ฤแบงu ra:$1.2/M
-20%

Mรฃ mแบซu vร  API cho MiniMax M2.1

Truy cแบญp mรฃ mแบซu toร n diแป‡n vร  tร i nguyรชn API cho MiniMax M2.1 ฤ‘แปƒ tแป‘i ฦฐu hรณa quy trรฌnh tรญch hแปฃp cแปงa bแบกn. Tร i liแป‡u chi tiแบฟt cแปงa chรบng tรดi cung cแบฅp hฦฐแป›ng dแบซn tแปซng bฦฐแป›c, giรบp bแบกn khai thรกc toร n bแป™ tiแปm nฤƒng cแปงa MiniMax M2.1 trong cรกc dแปฑ รกn cแปงa mรฌnh.

#!/bin/bash

# Get your CometAPI key from https://api.cometapi.com/console/token
COMETAPI_KEY="${COMETAPI_KEY:-<YOUR_COMETAPI_KEY>}"

# minimax-m2.1: MiniMax M2.1 model via chat/completions
curl -s https://api.cometapi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -d '{
    "model": "minimax-m2.1",
    "messages": [
      {
        "role": "user",
        "content": "Hello! Tell me a short joke."
      }
    ]
  }'

cURL Code Example

#!/bin/bash

# Get your CometAPI key from https://api.cometapi.com/console/token
COMETAPI_KEY="${COMETAPI_KEY:-<YOUR_COMETAPI_KEY>}"

# minimax-m2.1: MiniMax M2.1 model via chat/completions
curl -s https://api.cometapi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -d '{
    "model": "minimax-m2.1",
    "messages": [
      {
        "role": "user",
        "content": "Hello! Tell me a short joke."
      }
    ]
  }'

Python Code Example

from openai import OpenAI
import os

# Get your CometAPI key from https://api.cometapi.com/console/token
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)

# minimax-m2.1: MiniMax M2.1 model via chat/completions
completion = client.chat.completions.create(
    model="minimax-m2.1",
    messages=[
        {"role": "user", "content": "Hello! Tell me a short joke."}
    ]
)

print(completion.choices[0].message.content)

JavaScript Code Example

import OpenAI from "openai";

// Get your CometAPI key from https://api.cometapi.com/console/token
const COMETAPI_KEY = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const BASE_URL = "https://api.cometapi.com/v1";

const client = new OpenAI({
  apiKey: COMETAPI_KEY,
  baseURL: BASE_URL,
});

// minimax-m2.1: MiniMax M2.1 model via chat/completions
async function main() {
  const completion = await client.chat.completions.create({
    model: "minimax-m2.1",
    messages: [{ role: "user", content: "Hello! Tell me a short joke." }],
  });

  console.log(completion.choices[0].message.content);
}

main().catch(console.error);