---
title: "MiniMax M2 for OpenClaw: Pricing, Setup, and What It's Good At"
description: "Everything you need to know about using MiniMax M2 with OpenClaw. Costs $0.30/M input, $1.20/M output. 200K context window. Here's when to use it and when to pick something else."
date: 2026-03-12
updatedDate: 2026-03-12
image: /images/models/provider-minimax-hero.jpg
keywords: "minimax m2 openclaw, minimax m2 pricing, minimax m2 review, minimax openclaw, minimax m2 api"
category: model-guide
modelData:
  provider: "MiniMax"
  provider_slug: "minimax"
  full_id: "minimax/MiniMax-M2"
  input_cost_per_1m: 0.3
  output_cost_per_1m: 1.2
  max_input_tokens: 200000
  max_output_tokens: 8192
  features: ["function_calling", "reasoning"]
  parameter_count: null
  architecture: null
  license: null
faq:
  - question: "What are the token limits?"
    answer: "The model supports a 200K token context window and can generate up to 8K tokens in a single response."
  - question: "How much will I spend on high-volume tasks?"
    answer: "You will pay $0.30 per million input tokens and $1.20 per million output tokens, which is roughly 90% cheaper than GPT-4o."
---

Current as of March 2026. MiniMax M2 is a reasoning model from China's MiniMax lab. The pricing is blunt: $0.30 input, $1.20 output, 200K context. It's not trying to compete with Claude on quality — it's trying to compete on cost-per-token for tasks where you need a long context and a reasoning pass.

## Specs

| | |
|---|---|
| **Provider** | MiniMax |
| **Input cost** | $0.30 / M tokens |
| **Output cost** | $1.20 / M tokens |
| **Context window** | 200K tokens |
| **Max output** | 8K tokens |
| **Parameters** | N/A |
| **Features** | function_calling, reasoning |

## What it's good at

#### Price-to-Performance Ratio

$0.30/M input for a model with reasoning is genuinely cheap. You're getting something that can handle multi-step logic without paying GPT-4o rates.

#### Context Handling

200K tokens and the retrieval quality holds up reasonably well across the window. I haven't hit the severe needle-in-haystack degradation that plagues some of the cheaper models at this context size.

## Where it falls short

#### Inconsistent Latency

Time-to-first-token varies more than I'd like, especially through aggregator routing. Don't put this on a path where the user is waiting.

#### Dry Prose

The output is functional, not elegant. If you're generating text that a human will read, expect to edit it. Claude this is not.

## Best use cases with OpenClaw

- **Large-Scale Document Analysis** — 200K context + cheap input = a reasonable way to summarize entire codebases or legal archives without a RAG pipeline.
- **Structured Data Extraction** — The function calling works reliably, and at $1.20 output you can run this against a lot of records before costs get painful.

## Not ideal for

- **Creative Copywriting** — The model defaults to repetitive sentence structures. Heavy editing required.
- **Low-Latency Chatbots** — Too much variance in TTFT for anything user-facing that needs to feel fast.

## Run it through Haimaker

Skip juggling API keys. One Haimaker key gives you access to every model on the platform. Tell OpenClaw:

```
Add Haimaker as a custom provider to my OpenClaw config. Use these details:

- Provider name: haimaker
- Base URL: https://api.haimaker.ai/v1
- API key: [PASTE YOUR HAIMAKER API KEY HERE]
- API type: openai-completions

Add the auto-router model:
- haimaker/auto (reasoning: false, context: 128000, max tokens: 32000)

Create an alias "auto" for easy switching. Apply the config when done.
```

Or skip model selection entirely — Haimaker's [auto-router](/blog/openclaw-auto-router-setup/) picks the best model for each task so you don't have to.

## OpenClaw setup

Point your OpenClaw base URL to https://api.haimaker.ai/v1 and use your Haimaker API key; the model follows standard OpenAI-compatible schemas for function calling.

```json
{
  "models": {
    "mode": "merge",
    "providers": {
      "minimax": {
        "baseUrl": "https://api.haimaker.ai/v1",
        "apiKey": "YOUR-MINIMAX-API-KEY",
        "api": "openai-completions",
        "models": [
          {
            "id": "MiniMax-M2",
            "name": "MiniMax M2",
            "cost": {
              "input": 0.3,
              "output": 1.2
            },
            "contextWindow": 200000,
            "maxTokens": 8192
          }
        ]
      }
    }
  }
}
```

## How it compares

- **vs GPT-4o-mini** — 4o-mini is slightly cheaper on input ($0.15/M vs $0.30/M) and has stronger reasoning, but its context window caps at 128K.
- **vs DeepSeek-V3** — DeepSeek wins on coding. M2 tends to be steadier for general instruction following in longer agent loops.

## Bottom line

M2 makes sense when you need a reasoning pass over a large document and you don't want to pay GPT-4o prices to do it. Know what you're trading: cost efficiency in, not quality out.

<a href="https://app.haimaker.ai/sign-up?utm_source=model_guide&utm_medium=cta&utm_campaign=minimax-m2-openclaw" class="cta-button">TRY MINIMAX M2 ON HAIMAKER</a>

---

*For setup instructions, see our [API key guide](/blog/openclaw-api-key-setup). For all available models, see the [complete models guide](/blog/best-models-for-openclaw).*