# MiniMax API Pricing in 2026 and What Each Model Costs

By Desmond Achebe · 2026-10-15 · Source: https://www.activepieces.com/blog/minimax-api-pricing-in-2026-and-what-each-model-costs

---
<aside class="tldr"><p class="tldr-label">Summary</p><p>MiniMax M3 costs $0.30 per million input tokens and $1.20 per million output tokens for requests below 512k tokens, doubling above that threshold.</p><ul><li>1,000 email summaries cost $0.42 on MiniMax M3; deepseek-flash cost $0.21 at off-peak rates in the same test.</li><li>At 1M runs, MiniMax M3 bills $420 against $210 on the older V4 Flash.</li><li>Cached input reads cost $0.06 per million tokens, 80% less than fresh submissions.</li></ul></aside>

## MiniMax API pricing today, model by model

### The direct answer: input and output rates

On long generations the **output rate usually drives the bill**, because MiniMax bills input tokens and output tokens at separate per-million rates, a detail that is easy to miss when you wire model calls into [Activepieces](https://www.activepieces.com) flows and only watch prompt size.

![Two spouts of very different widths filling one tray](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/8abeab78-056e-4ba0-a6db-9e7298b337ac/minimax-api-pricing-in-2026-and-what-each-model-e34e6f17.webp)

The table in the next section gives the rates I could confirm against MiniMax's [Platform](https://platform.minimax.io/docs/pricing/overview) pricing overview on 2026-10-15.

Where a rate is marked "not confirmed", I could not verify it, and I print no guess because a wrong price is worse than a missing one.

Cost per run is input tokens times the input rate, plus output tokens times the output rate, divided by one million.

### Every model and tier in one table

Rates are in dollars per million tokens. MiniMax-M3 is the only model whose full rate card I could confirm, so it is the only one listed.

| Model and tier | Input | Output | Cached input | Context threshold | Source and date |
|---|---|---|---|---|---|
| MiniMax-M3, up to 512k | $0.30 | $1.20 | $0.06 | 512k tokens | Platform pricing page, 2026-10-15 |
| MiniMax-M3, past 512k | $0.60 | $2.40 | $0.12 | above 512k tokens | Platform pay-as-you-go guide, 2026-10-15 |

Check the threshold before you size a prompt. A request that crosses 512k tokens falls into the higher band, and **both the input and cached rates double**.

If your prompts repeat a long system message, the cached rate applies to that repeated part, so it's worth separating from fresh input. That is why cached input gets its own column.

### When the prices were checked

I checked on 2026-10-15. Treat any rate as perishable and read it from MiniMax's pricing page the day you commit.

Then run the formula per step. [Activepieces](https://www.activepieces.com) has 741 integrations in its open source monorepo, so each step in a flow can call a different model provider.

You price the classification step on a cheaper model than the drafting step instead of paying one rate for both.

## MiniMax subscription plans and their usage limits

Instead of per-token billing, a MiniMax plan charges a flat monthly fee that buys a fixed number of calls per rolling five-hour window. The question is whether your calls fill that window enough to beat pay-as-you-go.

A call here means one request sent to a model, not one token and not one workflow run. A flow with three model steps uses three calls each time it runs, so call volume compounds with execution frequency.

![Machine turning one parcel into three](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/38cd40c3-7c40-4507-9c68-da6473be3bce/minimax-api-pricing-in-2026-and-what-each-model-10de1e20.webp)

### Plan table: price, inclusions, limits

Read the last column as capacity.

| Plan | Price | Billing period | Calls per 5-hour rolling window |
|---|---|---|---|
| Plus | $22 | Monthly | 1,500 |
| Max | $55 | Monthly | 4,500 |
| Ultra | $132 | Monthly | 15,000 |

![Three subscription plan rows with increasingly tall stacks of call tokens](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/6a67eb91-3582-4890-ab6a-2ed2c73254ac/minimax-api-pricing-in-2026-and-what-each-model-eaebde48.webp)

Divide price by window capacity and Plus costs about $0.0147 per call of capacity. Max comes to about $0.0122, and Ultra about $0.0088, so the bigger plans cut the price of each call of capacity, as long as you use it.

Ultra is cheapest per call only if you keep it busy, and a half-used Ultra costs more per call actually made than a full Max.

### MiniMax pay-as-you-go versus plan break-even point

When your monthly pay-as-you-go spend on a workload is below the plan fee, the plan loses. When it's above, the plan wins, until you hit the window cap. The break-even is the plan price divided by what an average call costs you in tokens.

![Activepieces pricing page displaying four subscription tiers with features and costs.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/841ec84e-02e4-4761-aca2-e92f6d457f41/self-host-mistral-ai-enterprise-deployment-guide-c7d7dca9.webp)

So measure first. Run your real prompts, record input and output tokens per call, and multiply by the per-token rates.

### Who each plan suits

For a single person or a light automation whose calls come in bursts well under the window limit, Plus is the fit. Max fits a small team running several flows at once.

Ultra only makes sense when sustained, high-volume traffic keeps its window near full.

## What MiniMax costs at realistic automation volumes

Once you know your call count, a simple step turns out cheap.

1,000 email summaries cost about $0.42 on MiniMax M3, going by [MiniMax's pricing page](https://platform.minimax.io/docs/pricing/overview), and cost $0.21 on the older DeepSeek V4 Flash, making model selection a key cost lever, since the difference magnifies with summarization volume.

### 1,000 email summaries on MiniMax versus a cheaper model

I assume 800 input tokens and 150 output tokens per run, 950 in total. A thousand runs is 800,000 input and 150,000 output tokens.

At the table's M3 rates, the input costs $0.24 and the output $0.18. That makes $0.00042 a run, or $0.42 per 1,000. DeepSeek V4 Flash costs $0.00021 a run, or $0.21.

![A completed flow run showing trigger and step execution with HTTP request details and success status](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/bf7801a3-7dea-4788-a83a-1d3dde0fbc59/what-actually-transfers-when-you-migrate-off-aut-3c5ad478.webp)

The output is usually a label, so in practice your real output tokens may run below 150.

### Monthly cost at three volumes

Scale that per-run cost linearly and you get the table below.

| Runs a month | MiniMax M3 | DeepSeek V4 Flash |
|---|---|---|
| 1,000 | $0.42 | $0.21 |
| 10,000 | $4.20 | $2.10 |
| 100,000 | $42 | $21 |

**At 100,000 runs you save $21 a month**, which is trivial.

At 1M runs the bill is $420 on M3 against $210 on V4 Flash, and a $210 monthly difference is where routing starts to matter, so each inference's model assignment compounds across millions of requests.

![Monthly cost of MiniMax M3 against DeepSeek V4 Flash](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/0339dfe7-7ebe-4223-a9ec-18cbb354e67c/minimax-api-pricing-in-2026-and-what-each-model-a82b4689.svg "Source: MiniMax")

## Hidden costs and limits MiniMax users run into

Beyond the headline rate, five things move a MiniMax bill, and each shows up only after the first invoice:

- Thinking tokens billed as output, so the effort setting changes the count
- Cache reads at $0.06 per million tokens against $0.30 uncached
- Rate limits that differ by account tier
- Top-up minimums or expiry
- Price changes in the changelog

Set effort high and you multiply your most expensive line, because **MiniMax bills thinking tokens as output**. Test one step at low and high effort and compare the output count before you price a thousand runs.

### Cached input and token counts

Past 512k tokens, standard input is $0.60 per million and cache read is $0.12, per the [MiniMax pricing page](https://platform.minimax.io/docs/guides/pricing-paygo). That's one fifth, so **cached reads cost 80% less than fresh submissions**.

At the base rates it's $0.30 against $0.06, so the same cost advantage holds uniformly across all request sizes.

### How tokenizers change the count

The same text can count differently depending on the tokenizer. [Publor AI's counter](https://publorai.com/tools/token-counter/) puts the same 1,000 words at 1,342 tokens for GPT-5.x and 4o, 1,429 for Gemini, 1,409 for older Claude and 2,013 for newer Claude.

Newer Claude therefore **bills about 50% more tokens than GPT** for identical text, so compare per-token prices only after normalising the count.

### Rate limits, top-ups and retries

Where limits depend on your account tier, a cheap model throttled there can cost more in queue time than a pricier one that runs freely, so read your tier's limits before committing a workload.

Check the minimum top-up and whether balance expires, because unspent credit that lapses raises your effective rate. Tools and other features may be billed apart from tokens, so price them as their own line.

When a failed run resends a long prompt, it pays for the input again, at $0.60 per million past 512k unless the cache catches it.

## MiniMax pricing against the closest alternatives

Compare MiniMax with its rivals on the whole per-run formula (input tokens times input rate, plus output tokens times output rate, minus the cache discount). A lower headline rate loses if the model needs more tokens or retries.

### Comparison table on price, cache and context

I've left out price figures on purpose, since rates change and a stale number is worse than none. The table shows how each rival is positioned, so you know which pricing page to open and what to read off it.

| Model | Vendor's description | Fits which step |
|---|---|---|
| deepseek-flash | Fast, cheap, supports vision | Classifying tickets or reading attached images |
| deepseek-v4-pro | Higher-capability Pro model, no vision | Harder text reasoning |
| Z.ai GLM 5.3 | Open-weight text model, 1M context | Very long documents in one call |
| GPT-6 Luna | Efficient, built for cost-sensitive high-volume tasks | Bulk summarising |

On each vendor's page, record input, output, cached-input, context window and any subscription option, plus the date you checked.

### When MiniMax wins on cost

When your prompts repeat a large fixed prefix, such as instructions or a policy document, and MiniMax's cached-input rate is lower than the rival's, MiniMax wins.

If your volume is steady enough to use the plan's limits, a subscription also wins, because you pay a flat rate instead of a metered one.

### When a cheaper or pricier model is the better buy

For short, simple steps like classification, a cheaper model such as deepseek-flash or GPT-6 Luna usually costs less per run, since the extra capability goes unused. For steps that fail often, the pricier model can be cheaper, because every retry bills the whole prompt again.

My verdict is to route. Send the simple steps to the cheapest model that passes your tests, and keep MiniMax for the cache-heavy ones.

## Routing each step to the cheapest model with Activepieces

In Activepieces, each step in a flow can call its own model, so email summaries and ticket labels can go to a cheaper model while MiniMax keeps the harder steps and you pay its rates only there.

Activepieces has an MIT-licensed core and 741 integrations in its open source monorepo, and any model API without a dedicated integration can be called through a generic HTTP step on your own provider key.

Bring-Your-Own-Key is listed by tier on the Activepieces pricing page, so the spend lands on your MiniMax account at MiniMax's rate rather than at a resale rate.

The Activepieces side of the bill is a flat plan: $0 on the free tier, which carries unlimited flows, 1,000 credits a month and up to 5 users, then Plus at $20 a month, so the platform cost stays negligible relative to model spend.

![Activepieces pricing page showing four subscription tiers with features and pricing details.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/5780ea9c-6ecc-45f7-99f2-8707dfb01930/vercel-pricing-in-2026-how-the-costs-scale-scree-22533578.webp)

It doesn't change MiniMax's prices or plan limits. It changes how many of your steps are billed at them.

### Route by task difficulty

Put one expensive model on every step and you pay the premium on work a small model would pass, because a flow's cost is the sum of its steps.

Activepieces has a Router step that sends a run down one branch or another based on conditions you set, with an Otherwise branch for everything that matches neither, and because every plan including the free one has unlimited flows, a separate flow per route adds nothing to the platform bill.

![n8n AI Agent vs Activepieces AI Agent](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/e67a969e-f633-4a5b-a235-f6f88fac6280/deepseek-r1-vs-v3-for-business-ai-2026-guide-scr-191f01d5.webp)

Put a cheap classification step first, then let its output decide which branch runs.

In the canvas below, a Router has two conditional branches, each leading to its own agent step, and an Otherwise branch behind them.

*(screenshot)*

Point the simple branch at the cheapest model that passes your tests, and the branch that needs long context or heavy tool use at MiniMax.

The Otherwise branch is where you decide what unlabelled work costs, so make it the cheap default rather than the strong one.

### Cap spend and add a fallback model

Nothing about routing makes a bill bounded by itself. Set a spending limit with each model provider, and treat the flow's own failure handling as the second guard.

A step that errors or hits a rate limit can be retried, or its failure can be routed to a second model in a separate branch, so one throttled provider doesn't stall the run.

Choose the fallback for price as well as availability. A fallback that quietly costs several times the primary turns a rate-limit blip into a billing event.

Keep it on a model you have already tested on that step.

## Controlling MiniMax spend this week

Run these steps in order, because each one feeds the next and your own token counts, not the rate card, decide what you pay.

1. Log input and output tokens for every step of your workflow for a week, so you're pricing real traffic instead of a guess.
2.
3. Set a spend alert at a level slightly above your expected weekly total, so a looping step shows up as a notification rather than an invoice.
4. Test a cheaper model on the steps that only summarise or classify, and keep it only if the outputs match on a sample you can check.
5. Compare your plan against pay-as-you-go by break-even, as described below.
6. Put a recheck on the calendar.

Log per step, not per workflow, and record input and output separately. A single total hides the one step with a bloated prompt, and output tokens are typically priced higher, so a chatty step costs more than its length suggests.

### Choosing a MiniMax plan from your usage

Take your weekly cost at pay-as-you-go rates and set it against the plan's fee and its limits.

Below a certain run count, pay-as-you-go wins, and that count is the plan fee divided by your average cost per run.

Above it, the plan wins only if its rate limits don't throttle your busiest hour. If you can't work out those limits from the published page, treat that as a cost in itself.

Because prices, plan limits and model lineups change, rerun steps one and two on a fixed date, so a new tier or a revised rate gets compared against your logs instead of noticed by accident.

## Frequently asked questions

### Free usage and failed requests

Is there a free tier for the MiniMax API? Treat any free allowance as something to verify, not something to budget around.

Promotional credits and trial quotas change, so read the current terms on MiniMax's pricing page during your fixed-date rerun. If a free allowance exists, test with it, but price production as though it were absent.

Does MiniMax charge for failed or cancelled requests? Assume you pay for any tokens the model actually generated, and confirm what happens on errors in MiniMax's billing documentation.

A request that fails before generation should cost nothing. One you cancel mid-stream may still bill the tokens produced so far.

### Subscriptions and price changes

Can I use a MiniMax subscription plan through the API? Don't assume it. **A subscription plan and pay-per-token API access are separate billing arrangements until the plan's own terms say otherwise.**

Read the plan's usage rules before wiring it into an automated pipeline, because a plan that doesn't cover API calls means you pay twice for the same work.

How often does MiniMax change its prices? Often enough that a quote from last quarter isn't a quote.

New models arrive with their own rates, and existing tiers get revised. That's why your cost check should be a dated, repeatable routine against your own logs rather than a one-time lookup.

### Currency

Is MiniMax billed in dollars or yuan? Check the billing page before you compare any rate with a Western provider's, because the currency follows the platform and account you sign up on.

If your invoice is in a different currency from the price you read, convert both sides on the same date. Otherwise an exchange-rate swing will look like a price change.

## Related reading

- [Gemini API Pricing 2026: Every Model, Tokens & Limits](https://www.activepieces.com/blog/gemini-api-pricing-2026-every-model-tokens-limits)
- [Vercel Pricing in 2026: How the Costs Scale](https://www.activepieces.com/blog/vercel-pricing-in-2026-how-the-costs-scale)
- [Power Automate Pricing: Plans & Costs in 2026](https://www.activepieces.com/blog/power-automate-pricing-plans-costs-in-2026)

## References

- [Publor AI](https://publorai.com/tools/token-counter/)
- [MiniMax](https://platform.minimax.io/docs/pricing/overview)
- [MiniMax](https://platform.minimax.io/docs/guides/pricing-paygo)
