API model string
open-mixtral-8x7bContext window
32K tokens
Max output not published
- Knowledge cutoff
- not published
- Released
- 2023–2024
- Modalities
- text in, text out
Last verified July 10, 2026
Rate limits by tier
Mixtral 8x7B has no confirmed active first-party SKU on La Plateforme as of July 2026. Practical access is through third-party inference hosts (Groq, Together AI, Fireworks AI, DeepInfra) or self-hosting under the Apache 2.0 license. Each host maintains its own rate-limit tier system.
| Tier | Requirements | RPM | TPM | RPD | Concurrent | Notes |
|---|---|---|---|---|---|---|
| La Plateforme (historical/unconfirmed) | Account on mistral.ai; first-party availability unconfirmed — verify on mistral.ai/pricing before use | not published (legacy) | not published | not published | not published | Model was previously listed as open-mixtral-8x7b; delisted from current pricing page per research. Do not rely on this endpoint without verifying current availability. |
| Groq (third-party) | Groq account at console.groq.com; free tier available, no card required for eval | host-dependent (check Groq console for current Mixtral 8x7B free limits) | host-dependent | host-dependent | not published | Groq's LPU hardware delivers among the fastest Mixtral 8x7B inference speeds. Free tier has documented RPM/RPD limits; check Groq console for current figures. Groq adds x-ratelimit-* response headers for precise backoff. |
| Together AI / Fireworks AI / DeepInfra (third-party) | Account on respective host; typically pay-as-you-go | host-dependent | host-dependent | host-dependent | not published | Prices range roughly $0.10–0.60/MTok blended across hosts (verify on each host's pricing page — rates change frequently). Each host has its own tier and limit structure. |
| Self-hosted (Apache 2.0) | ~90GB VRAM FP16 (e.g., 7× A100 40GB) or ~45GB VRAM at int4 quantization | unlimited (hardware-constrained) | unlimited (hardware-constrained) | unlimited | hardware-constrained | Apache 2.0 license: free to self-host commercially with no licensing fee. Zero per-token cost; infrastructure cost only. Quantized int4 checkpoints halve the VRAM requirement with acceptable quality trade-off. |
Swipe the table sideways to see every limit column.
- 1.Open weights (Apache 2.0) on Hugging Face are available indefinitely regardless of first-party API status.
- 2.Context window is 32K tokens — significantly narrower than current models (Mistral Medium 3.5: 128K, Llama 4 Scout: 10M native). Factor this into migration planning.
- 3.Third-party host prices for Mixtral 8x7B vary up to ~3.8× across providers; always compare Groq, Together AI, Fireworks AI, and DeepInfra before committing to a host.
Limits verified against the Mistral AI docs, July 10, 2026.
Token pricing
What you pay per million tokens (USD). Input and output are billed separately.
Input
$0.35
per 1M tokens
Output
$0.60
per 1M tokens
- No published first-party price on La Plateforme as of July 2026. The $0.35/$0.60 figures are illustrative mid-range estimates across third-party hosts (per third-party trackers — verify on the specific host before quoting). Groq free tier is $0 up to limits.
- Third-party host pricing ranges: roughly $0.10–0.60/MTok blended across Groq, Together AI, Fireworks AI, and DeepInfra (verify per host — rates change frequently).
- Self-hosting cost = GPU infrastructure only; $0 per-token under Apache 2.0 license.
- Batch discount availability depends on the third-party host used; not uniformly available across all hosts.
Side-project prototyping on Groq free tier
~$2.35 (or $0 on Groq free tier up to limits)
per month
Assumptions
5M in / 1M out per month at illustrative mid-range third-party rate ~$0.35 in / $0.60 out
5M × $0.35/MTok = $1.75 + 1M × $0.60/MTok = $0.60 ≈ $2.35 — verify on your chosen host; Groq free tier may cover small volumes at $0
Mid-volume automation pipeline on paid third-party host
~$28.20
per month
Assumptions
60M in / 12M out per month at illustrative $0.35/$0.60 per MTok
60M × $0.35/MTok = $21.00 + 12M × $0.60/MTok = $7.20 ≈ $28.20 — verify on your chosen host; actual rate varies significantly across providers
High-volume pipeline — consider migrating to current models
~$188
per month
Assumptions
400M in / 80M out per month at illustrative $0.35/$0.60 per MTok
400M × $0.35/MTok = $140 + 80M × $0.60/MTok = $48 ≈ $188 — for this volume, evaluate Mistral Small 3.1 (128K context, active development) or self-hosting at ~$0 per-token
Run your own numbers
Drag your real monthly token volumes and watch the bill update live — priced against rival models at the same usage.
Estimated open-mixtral-8x7b spend
$14/mo
Input: $11
Output: $3.00
30M in × $0.350 + 5M out × $0.600 = $14
Same volume, priced across models
- Llama 4 ScoutCheapest$3.90
- open-mixtral-8x7bThis model$14
- Mistral Medium 3.5$22
- Mixtral 8x22B$90
Rivals priced at their published input/output rates for the same monthly volumes. Prompt caching is model-specific, so it is applied to open-mixtral-8x7b only. Estimates for comparison; real bills vary with request shape and long-context surcharges.
open-mixtral-8x7b vs the alternatives
Mixtral 8x7B sits in the legacy MoE tier — compare it against its larger sibling Mixtral 8x22B, the current active mid-tier Mistral Medium 3.5, and Llama 4 Scout as the modern open-weight MoE alternative.
| Aspect | open-mixtral-8x7b | Mixtral 8x22B | Mistral Medium 3.5 | Llama 4 Scout |
|---|---|---|---|---|
| Architecture | MoE sparse (12.9B active / 46.7B total params) | MoE sparse (39B active / 141B total) | Dense | MoE sparse |
| Context window | 32K tokens | 65K tokens | 128K tokens | 10M native (host-capped) |
| First-party API | Not published (legacy, possibly delisted) | Unconfirmed (legacy) | Active (La Plateforme, EU) | Third-party only |
| Third-party input $/MTok | ~$0.10–0.60 (verify per host) | ~$2.00 hist (verify) | $0.40–1.50 (verify) | $0.08–0.15 |
| Third-party output $/MTok | ~$0.10–0.60 (verify per host) | ~$6.00 hist (verify) | $2.00–7.50 (verify) | $0.30–0.60 |
| Open weights license | Apache 2.0 (commercial self-host free) | Apache 2.0 | None (closed) | Llama 4 community license |
| Groq free tier | Yes (fastest inference option) | No | No | No |
| Active development | No (legacy) | No (legacy) | Yes | Yes |
| VRAM to self-host | ~45GB int4 / ~90GB FP16 | ~70GB int4 / ~141GB FP16 | No self-host | Open weights, large |
Swipe the table sideways to see every model.
Hitting a 429? The playbook
The exact errors you'll see
HTTP 429 Too Many Requests (Groq, Together AI, Fireworks AI, DeepInfra — standard HTTP status)rate_limit_error (La Plateforme OpenAI-compatible format, if endpoint still active)x-ratelimit-limit-requests / x-ratelimit-remaining-requests / x-ratelimit-reset-requests (Groq response headers — read these for precise backoff)Why it happens & how to fix it
Groq free tier RPM or RPD limit exhausted for Mixtral 8x7B
Implement exponential backoff honoring Groq's x-ratelimit-reset-requests header, or upgrade to Groq paid plan. Alternatively, distribute load across Together AI or Fireworks AI.
Third-party host daily token limit exhausted
Switch to another third-party host (Groq, Together AI, Fireworks AI, DeepInfra) or upgrade your plan on the current host. Each host has independent limits — check their dashboards.
La Plateforme 'model not found' error (model may be delisted)
Mixtral 8x7B may no longer be an active SKU on La Plateforme. Switch to a third-party host or migrate to Mistral Small 3.1 on La Plateforme.
Context window exceeded (32K tokens)
Mixtral 8x7B's 32K context is a hard limit — truncate input or switch to a model with wider context (Mistral Medium 3.5 at 128K or Llama 4 Scout for very long contexts).
Self-host GPU out-of-memory (OOM) error
Mixtral 8x7B requires ~90GB VRAM at FP16. Use a quantized int4 checkpoint to run on ~45GB VRAM (3–4 A100 40GB). For eval, prefer Groq free tier over self-hosting.
Retry strategy
Honor the Retry-After header in the 429 response (available on La Plateforme and most third-party hosts). On Groq, additionally read x-ratelimit-reset-requests to know exactly when your quota resets. Use exponential backoff: delay = min(2^attempt, 60) seconds plus ±10% random jitter to avoid thundering-herd collisions. Spread retries across multiple hosts when one is rate-limiting.
1// retry.ts — Mixtral 8x7B via OpenAI-compatible endpoint (Groq example)2import OpenAI from "openai";34const client = new OpenAI({5 apiKey: process.env.GROQ_API_KEY,6 baseURL: "https://api.groq.com/openai/v1", // swap for Together/Fireworks/La Plateforme7});89async function callWithRetry(10 prompt: string,11 maxAttempts = 512): Promise<string> {13 for (let attempt = 0; attempt < maxAttempts; attempt++) {14 try {15 const res = await client.chat.completions.create({16 model: "mixtral-8x7b-32768", // Groq model ID; La Plateforme: "open-mixtral-8x7b"17 messages: [{ role: "user", content: prompt }],18 });19 return res.choices[0].message.content ?? "";20 } catch (err: unknown) {21 if (22 err instanceof Error &&23 "status" in (err as { status?: number }) &&24 (err as { status?: number }).status === 42925 ) {26 const headers = (err as { headers?: Record<string, string> }).headers;27 // Groq: prefer x-ratelimit-reset-requests; fallback to Retry-After28 const resetHeader =29 headers?.["x-ratelimit-reset-requests"] ??30 headers?.["retry-after"];31 const waitMs = resetHeader32 ? parseFloat(resetHeader) * 100033 : Math.min(Math.pow(2, attempt) * 1000, 60_000);34 const jitter = waitMs * (0.9 + Math.random() * 0.2);35 console.warn(`429 rate limited. Retrying in ${Math.round(jitter)}ms (attempt ${attempt + 1})`);36 await new Promise((r) => setTimeout(r, jitter));37 } else {38 throw err;39 }40 }41 }42 throw new Error("Max retry attempts reached for Mixtral 8x7B request");43}How to raise your limits
The ladder from the starter tier to enterprise — what each rung takes, and what it unlocks.
Groq Free Tier
Immediate accessCreate a free Groq account at console.groq.com; select Mixtral 8x7B model. No credit card required. Check the Groq console for current RPM/RPD limits on Mixtral 8x7B (limits change; not published as fixed numbers).
Unlocks: Fast LPU inference for eval and prototyping; zero cost up to free limits
Groq Paid Plan
Immediate after billing enabledAdd billing on console.groq.com. Higher rate limits than free tier; same fast LPU inference.
Unlocks: Higher RPM/RPD ceiling; suitable for small production workloads
Together AI / Fireworks AI / DeepInfra (pay-as-you-go)
Immediate after account creationCreate account on the respective host; select Mixtral 8x7B (model IDs vary: Together uses 'mistralai/Mixtral-8x7B-Instruct-v0.1'). Pay-as-you-go at ~$0.10–0.60/MTok blended (verify per host).
Unlocks: Alternative to Groq when Groq limits are hit; compare prices across hosts before committing
Self-Hosted (Apache 2.0)
Setup time: hours to days depending on infraDownload open weights from Hugging Face (mistralai/Mixtral-8x7B-Instruct-v0.1). Run at FP16 on ~90GB VRAM or int4 on ~45GB VRAM using vLLM or llama.cpp.
Unlocks: Zero per-token cost; unlimited throughput limited only by hardware; full data sovereignty; no license fee under Apache 2.0
Migrate to Current Models
Recommended immediately for new projectsFor new projects, use Mistral Small 3.1 (La Plateforme, 128K context, active development) or Mistral Medium 3.5 for mid-tier tasks. Both have EU data residency and active API support.
Unlocks: 4× wider context window (128K vs 32K), active model development, confirmed first-party API with EU residency
Cut your token spend
Use Groq for latency-critical inference
Among the fastest available Mixtral 8x7B throughput (~450+ tokens/second reported); free tier availableRoute Mixtral 8x7B requests through Groq's OpenAI-compatible endpoint (https://api.groq.com/openai/v1). Groq's LPU hardware is purpose-built for fast token generation. Free tier handles eval and low-volume production — per third-party trackers, confirm current limits in Groq console.
Apache 2.0 self-hosting for zero per-token cost
Eliminates per-token fees entirely; economics improve drastically above ~50M tokens/monthDownload mistralai/Mixtral-8x7B-Instruct-v0.1 from Hugging Face. Deploy with vLLM or llama.cpp on ~90GB VRAM FP16 or ~45GB VRAM int4. Apache 2.0 allows commercial use without licensing restrictions.
Quantized int4 inference to halve VRAM requirements
Reduces VRAM from ~90GB to ~45GB (~50% reduction) with moderate quality trade-offUse a pre-quantized GGUF checkpoint from Hugging Face and run via llama.cpp; 3–4 A100 40GB GPUs suffice vs 7+ at FP16. Quality loss is acceptable for most instruction-following tasks.
Compare third-party host prices before committing
Potential cost savings of up to ~3.8× by picking the cheapest host for your volumeCheck Groq, Together AI, Fireworks AI, and DeepInfra pricing pages before signing up. Rates for Mixtral 8x7B vary significantly and change frequently — benchmark your actual token distribution on each host's calculator.
Cap requests at 32K context — truncate aggressively
Prevents hard 'context exceeded' errors; avoids wasted API callsMixtral 8x7B's 32K context window is a binding constraint. Truncate conversation history or documents to stay well under the limit (leave ~2K buffer for output). For longer contexts, migrate to Mistral Medium 3.5 (128K) or Llama 4 Scout.
Migrate to Mistral Small 3.1 for new production workloads
4× wider context (128K vs 32K); active development and La Plateforme EU residencyMistral Small 3.1 is the recommended current replacement. Update the model string and base URL; the instruction-following format is similar enough that prompt changes are usually minimal.
Frequently asked questions
Does Mixtral 8x7B still have a working API in 2026?
Mixtral 8x7B is a legacy model with no published first-party price on La Plateforme as of July 2026. The most reliable access paths are Groq (free tier available), Together AI, Fireworks AI, and DeepInfra, which all serve the open weights. La Plateforme first-party availability is unconfirmed — verify on mistral.ai/pricing before relying on it.
Is Mixtral 8x7B free to use?
Yes, in two ways. First, Groq offers a free tier with rate limits for Mixtral 8x7B — check console.groq.com for current RPM and RPD limits. Second, the open weights are Apache 2.0 licensed, meaning you can self-host commercially at zero per-token cost (hardware cost only, requiring ~45GB VRAM at int4). Paid third-party hosting runs roughly $0.10–0.60/MTok blended (verify per host).
How do I increase Mixtral 8x7B rate limits?
For Groq: upgrade from free to a paid plan at console.groq.com to unlock higher RPM and RPD limits. For other third-party hosts (Together AI, Fireworks AI, DeepInfra): upgrade your plan on the respective host's dashboard. For unlimited throughput, self-host the Apache 2.0 open weights on your own GPU infrastructure (~45GB VRAM at int4, ~90GB at FP16).
Mixtral 8x7B vs Mistral Medium 3.5 — which should I use?
For new projects, Mistral Medium 3.5 is the recommended choice: it has 128K context (vs Mixtral 8x7B's 32K), an active first-party API on La Plateforme with EU data residency, and ongoing model development. Mixtral 8x7B makes sense only if you have an existing integration you cannot migrate, need Groq's free tier for prototyping, or want to self-host at the smallest possible VRAM footprint.
What does the Mixtral 8x7B 429 error mean and how do I fix it?
A 429 Too Many Requests error means you have hit your rate limit on the inference host. On Groq, read the x-ratelimit-reset-requests response header to know exactly when your quota resets. On other hosts, honor the Retry-After header. Use exponential backoff: wait = min(2^attempt, 60) seconds plus ±10% jitter. If you consistently hit limits, upgrade your plan or distribute load across multiple hosts.
How much VRAM does Mixtral 8x7B need to self-host?
Mixtral 8x7B requires approximately 90GB VRAM at FP16 precision (7 or more A100 40GB GPUs) or approximately 45GB VRAM using int4 quantization (3–4 A100 40GB GPUs). The int4 quantized checkpoint on llama.cpp or vLLM is the practical self-hosting path for most teams. The Apache 2.0 license allows commercial self-hosting with no licensing fee.
What is the Mixtral 8x7B context window limit?
Mixtral 8x7B supports a maximum context window of 32K tokens. This is significantly narrower than current models — Mistral Medium 3.5 supports 128K tokens and Llama 4 Scout supports up to 10M tokens natively. If your application requires longer conversations or larger documents, migrate to a model with a wider context window.
Can RapidDev help migrate from Mixtral 8x7B to current Mistral models?
Yes. RapidDev's engineering team handles AI gateway and model-migration work including updating model strings, re-benchmarking prompts for context differences, and configuring retry logic across new endpoints. For a free scoping call, visit rapidevelopers.com/contact.
We build AI apps that don't hit rate limits
- Retry, backoff & caching built in
- Multi-provider fallback routing
- Fixed price, you own the code
30-min call. No commitment.