MiniMax M3 API pricing runs $0.30 per million input tokens and $1.20 per million output tokens on the standard tier, for prompts up to 512K tokens, per MiniMax's own pricing page. That's cheap against most frontier APIs, and it gets cheaper still now that MiniMax has shipped M3.1 Flash, a successor priced at exactly half M3's rate. Both facts change the math for teams weighing MiniMax's hosted API against self-hosting the open-weight checkpoint on rented GPUs. This post lays out what the API actually charges across its tiers, what self-hosting M3 costs per token on real GPU hardware, where MiniMax stores your data, and the token volume at which renting your own cluster starts to win.
TL;DR: MiniMax M3 API Pricing vs Self-Hosted LLMs
- Standard tier: MiniMax M3 costs $0.30/M input and $1.20/M output for prompts up to 512K tokens, rising to $0.60/M and $2.40/M beyond 512K, per MiniMax's pricing page.
- Priority tier: costs 1.5x standard, $0.45/$1.80 per million up to 512K and $0.90/$3.60 beyond it.
- M3.1 Flash: MiniMax's successor, released 19 Oct 2026, halves M3's rate to $0.15/M input and $0.60/M output.
- Self-hosted: M3 on a 4x H200 SXM5 spot cluster at FP8 cost roughly $2.53 per million tokens at ~800 tok/s sustained throughput, per Spheron's own M3 deployment numbers.
- Privacy: MiniMax's API Terms put stored data in a US data center, but there's no public SOC 2, ISO 27001, HIPAA-eligible tier, or signed DPA for the API as of mid-2026.
- Spheron runs H200 at $5.54/hr on-demand as of 25 Oct 2026. See the GPU cost-per-token benchmarks for the underlying throughput data.
MiniMax M3 API Pricing: What You Actually Pay Per Million Tokens
MiniMax M3 is an open-weight Mixture-of-Experts model with 428B total parameters and roughly 23B activated per token, built for agentic coding work with a context window up to 1M tokens. You can run it yourself from the published weights, or call it through MiniMax's hosted API, which bills by service tier and by prompt length.
MiniMax splits pricing two ways: a service tier (Standard or Priority, where Priority trades a price premium for faster, more consistent response times) and a context tier (whether your prompt falls under or over 512K input tokens). Here's the full rate card:
| Tier | Context | Input (per M) | Output (per M) |
|---|---|---|---|
| Standard | ≤512K tokens | $0.30 | $1.20 |
| Standard | >512K tokens | $0.60 | $2.40 |
| Priority | ≤512K tokens | $0.45 | $1.80 |
| Priority | >512K tokens | $0.90 | $3.60 |
| M3.1 Flash | Standard | $0.15 | $0.60 |
Source: MiniMax Pricing Overview.
The rate card above reflects MiniMax's published pricing as of this post's date; providers revise API rates without much notice, so check MiniMax's pricing page directly before you budget against it.
MiniMax describes the $0.30/$1.20 standard rate as a permanent 50% discount off a $0.60/$2.40 list price, the same numbers that apply automatically once a prompt crosses 512K input tokens. So the step up at 512K isn't a new fee, it's the list rate the short-context tier is already discounted against. M3.1 Flash also lists a published cache-read price, $0.015 per million tokens, a discount worth checking for any workload that repeats a system prompt or tool schema across calls.
M3.1 Flash is the newest wrinkle here. MiniMax shipped it on 19 Oct 2026 as M3's successor, and it prices at exactly half M3's standard rate: $0.15/M input and $0.60/M output. The checkpoint itself is smaller too, 252.4GB across 48 shards plus a 2.3GB speculative-decoding drafter, against M3's roughly 428GB FP8 footprint. If you're pricing out MiniMax today rather than mid-2026, M3.1 Flash is the rate that actually matters, not M3's.
Self-Hosting MiniMax M3 on Rented GPUs: Cost Per Token
Spheron's own MiniMax M3 deployment guide ran the self-hosted math directly: FP8 M3 on a 4x H200 SXM5 spot cluster, at $7.28/hr spot (12 Jun 2026 rates) and roughly 800 tokens/second of sustained throughput, worked out to about $2.53 per million tokens. The formula behind that figure is straightforward: (price_per_hour / throughput_toks_per_sec / 3600) * 1,000,000. Swap in your own measured throughput and current Spheron rates to rerun it for your workload.
That $2.53/M figure sits between MiniMax's own tiers rather than cleanly beating or losing to all of them. Matching it against each output rate tells you the throughput you'd need to hold on a self-hosted cluster to break even:
| API tier (output rate) | Throughput needed on 4x H200 spot to match it |
|---|---|
| Standard, ≤512K ($1.20/M) | ~1,690 tok/s |
| Priority, ≤512K ($1.80/M) | ~1,123 tok/s |
| Standard, >512K ($2.40/M) | ~840 tok/s |
| Priority, >512K ($3.60/M) | ~562 tok/s |
| M3.1 Flash ($0.60/M) | ~3,370 tok/s |
The last row is the headline change M3.1 Flash introduces. Against M3's own standard rate for prompts over 512K, a 4x H200 FP8 cluster needs about 840 tok/s sustained to break even, a bar real production deployments clear. Against M3.1 Flash's $0.60/M output rate, the same cluster would need roughly 3,370 tok/s, a throughput M3's self-hosted cost basis above was never built to hit. M3.1 Flash's own architecture helps close some of that gap on paper: its KV cache per token drops 43.75% versus M3 (from 61,440 bytes to 34,560 bytes per token), which raised measured concurrency from 28 to 76 sequences at 256K context on a 4x B300 cluster. Higher concurrency on the same hardware pushes aggregate throughput up, but there's no published Spheron cost-per-token figure for M3.1 Flash specifically yet, so until someone runs that worked example, the honest comparison is M3's own established numbers against M3.1 Flash's API rate, not an assumed self-hosted number for M3.1 Flash itself.
Spot capacity is the lever doing most of the work in that $2.53/M figure, and it comes with a real tradeoff. Every 8-GPU spot type we used was reclaimed at least once on 14 Oct 2026, and on 16 Oct one B200 region stopped five of our spot VMs in a day. A 428B-parameter MoE model with a multi-minute cold start doesn't tolerate that kind of reclaim gracefully in a production path; it's fine for batch jobs you can restart, but sustained serving needs either on-demand pricing or a redundant multi-node spot layout, not a single spot node you hope stays up.
That's the layout we actually run: since 16 Oct 2026 we run every model as two copies on two different 8xB200 nodes, so a spot reclaim never takes a model down, and idle copies get a warm-up request every minute. A self-hosted M3 deployment aiming for the same reliability needs that same two-node redundancy before it needs a faster GPU.
Pricing fluctuates based on GPU availability. Spheron rates above are live as of 25 Oct 2026; the self-hosted cost-per-token figures are frozen at the rates recorded in Spheron's M3 deployment guide, and MiniMax's own API rates may have changed since this post's publish date. Check current GPU pricing → for live rates, and MiniMax's pricing page for current API rates.
Privacy and Data Residency: API vs Self-Hosted
MiniMax's hosted API is a different data-handling story from most of the other Chinese-lab APIs teams compare it against. Its API Privacy Policy and API Terms state that personal data collected through the API is stored in a US data center. That's a meaningful distinction if your compliance team has been treating every China-headquartered model lab's API the same way DeepSeek's is treated, where prompt data is stored in China under a legal framework that compels state cooperation.
It doesn't settle the question entirely, though. A US storage location is a claim about where bytes sit, not a certification of how they're handled. As of mid-2026, no public SOC 2 Type II report, ISO 27001 certificate, HIPAA-eligible tier, or public DPA has been found for MiniMax's API. For a security team doing due diligence, that's a real gap: there's a location claim to evaluate but little third-party audit evidence to check it against.
This is also where the open-weight question (the one behind "is MiniMax free for commercial use?") actually matters for teams that decide the API isn't a fit. MiniMax ships M3 under the MiniMax Community License, which runs free for non-commercial use. Commercial use is free too below $20M in trailing annual revenue, with a "Built with MiniMax" attribution requirement and a one-time notice to MiniMax; above that revenue threshold, you need prior written authorization. That's a materially more permissive license than a model you can only access metered through an API, and it's what makes self-hosting a real option rather than a workaround: once you're running the weights yourself, on infrastructure you control, MiniMax's own data-residency terms stop applying to your traffic at all. If you're comparing this same tradeoff against a different Chinese-lab API, the DeepSeek API pricing vs self-hosted and Kimi API pricing vs self-hosted breakdowns cover the China National Intelligence Law exposure that MiniMax's US-storage claim sidesteps in a different way than either of those two handles it.
Breakeven: When Self-Hosting Beats the API
The decision comes down to two separate questions that don't always point the same direction: what does your sustained throughput actually cost per token on each side, and does your data have a residency or compliance constraint that overrides the cost math entirely.
| Use MiniMax's API when | Self-host on GPU cloud when |
|---|---|
| Daily volume stays well under the throughput needed to beat your target tier (see the table above) | Your sustained throughput genuinely clears ~840 tok/s (vs M3 standard >512K) or higher, depending on tier |
| M3.1 Flash's $0.15/$0.60 rate already undercuts what a self-hosted cluster can match | You need full control over prompt and completion data, independent of MiniMax's own storage terms |
| You have no data-residency, audit, or IP-sensitivity requirement that needs a signed BAA or SOC 2 report | Any compliance requirement needs evidence MiniMax doesn't currently publish |
| You want the lowest engineering overhead and no GPU fleet to manage | You can run redundant nodes against spot reclaim risk, or pay on-demand for SLA-backed serving |
For teams below the throughput crossover, MiniMax's API, especially M3.1 Flash at half M3's rate, is simply cheaper than standing up a GPU cluster. For teams that clear it, or that have a compliance requirement no API vendor's current documentation satisfies, the self-hosted M3 deployment guide linked above walks through the vLLM and SGLang setup on H100 and H200 clusters, and the GPU cost-per-token benchmarks linked in the TL;DR cover how to measure your own throughput before committing to a GPU tier. Teams evaluating MiniMax's full open-weight lineup, not just the text model, can also check the MiniMax H3 deployment guide for the video-generation release. Spheron's docs cover provisioning in more depth if you're standing up your first node.
If your MiniMax usage is climbing toward the throughput where self-hosting wins, or your prompts can't leave your own infrastructure, benchmark M3 against your own eval set on a rented H200 cluster before your next billing cycle.
Frequently Asked Questions
Open-weight MiniMax M3 runs free for non-commercial use under the MiniMax Community License. Commercial use is also free below $20M in trailing annual revenue, but it requires a 'Built with MiniMax' attribution and a one-time notice to MiniMax; above that revenue threshold you need prior written authorization. The hosted API is a separate, metered product billed per token regardless of revenue.
MiniMax M3 is an open-weight Mixture-of-Experts language model with 428B total parameters and roughly 23B activated per token, built for coding and agentic workloads with a context window up to 1M tokens. It is available both as open weights for self-hosting and as a metered API through MiniMax's own platform.
On the standard service tier, M3 costs $0.30 per million input tokens and $1.20 per million output tokens for prompts up to 512K tokens, and $0.60/$2.40 per million for prompts beyond 512K. The Priority service tier runs 1.5x those rates: $0.45/$1.80 per million up to 512K, and $0.90/$3.60 per million beyond it.
Yes. MiniMax M3.1 Flash, released 19 Oct 2026 as M3's successor, prices at $0.15 per million input tokens and $0.60 per million output tokens, plus $0.015/M on a cache read, exactly half M3's standard-tier rate. It also cuts KV cache per token by 43.75% versus M3, which raises self-hosted concurrency substantially on the same hardware.
