Mistral API Pricing: Rates, Modes, and Real Cost

Mistral API pricing: the short answer

Mistral bills per million tokens, input and output priced separately, and your rate depends on the model and the serving mode. On Mistral's rate card at mistral.ai/pricing/api, read September 17, 2026, Mistral Small 4 is $0.15 input and $0.60 output per million tokens. Mistral Medium 3.5 is $1.50 in and $7.50 out.

The rate card tells you the unit price. It cannot tell you how many times a workflow pays it. If you run a recurring workflow on Mistral, Major cuts that count: the agent builds an app for the repeatable steps, so the model is called only for judgment. More on that below.

Mistral API rates by model

Mistral prints no effective date on the page, so treat these as a snapshot and re-read the source before you commit a budget.

• Mistral Small 4: $0.15 input, $0.60 output. The cheapest general text model.
• Mistral Large 3: $0.50 input, $1.50 output. Cheaper than Medium 3.5 on both sides, which breaks the naming intuition.
• Mistral Medium 3.5: $1.50 input, $7.50 output. The highest published output rate.
• Codestral: $0.30 input, $0.90 output. Code-focused.
• Ministral 3 (3B, 8B, 14B): $0.10, $0.15 and $0.20, with output priced the same as input.
• Mistral Embed: $0.10 input only. Codestral Embed is $0.15.
• GLM 5.3: $1.40 input, $4.40 output. Third-party model served through Mistral.

Not everything is token-billed. OCR 4.1 is $4 per 1,000 pages, Document AI is $5 per 1,000 pages, and Voxtral Mini Transcribe is $0.003 per audio minute. Enterprise APIs are described as 75 percent above list pricing on select APIs, which is a surcharge, not a discount.

Is the Mistral API free?

There is no open free tier on the API. Mistral bundles credit into its subscription plans: $10 per month on the free plan, $30 on Pro, $15 for verified students. Moderation 2 is listed as free. Everything past the bundled credit bills at API rates.

Standard, batch, cached and priority modes

Mode is the second axis of price, and it moves the number as much as the model does.

• Batch is half the standard price. It fits overnight classification, backfill enrichment and scheduled scoring, where no human waits on the response.
• Cached input carries a 90 percent reduction on the input side for repeated prompt prefixes. Put the stable system prompt and retrieved context first and the volatile part last.
• Regional inference on a global or EU endpoint adds 10 percent.
• Priority is offered for fast, predictable compute, but the pricing page publishes no rate. You have to ask sales.

Every quote is a triple of model, mode and region. Drop one leg and the forecast is wrong in a direction you will not notice until the invoice.

How to calculate a real Mistral request cost

For one call, cost = (input_tokens x input_price / 1e6) + (output_tokens x output_price / 1e6).

Input tokens are where estimates go wrong, because they are not just the user's message. They are the system prompt, tool schemas, conversation history, retrieved documents and the user's message together. A 40-token question can easily arrive as several thousand input tokens.

Scale it with monthly_cost = requests x retry_multiplier x cost_per_call x mode_multiplier x region_multiplier. The retry multiplier is 1 plus your observed rate of timeouts, refusals and malformed structured output. Batch is 0.5, a pinned regional endpoint is 1.10, and the cache discount applies only to the cacheable share of input.

Three costs sit outside the model line:

• Tool cost. Code execution and web search are $30 per 1,000 calls each, and image generation is $100 per 1,000 images. An agent that searches twice per task pays $60 per 1,000 tasks before a token is billed.
• Infrastructure. Vector store, queue, orchestration runtime, logging and retention. None of it appears on a model provider's page.
• Human review. Often the largest line in a production workflow and the easiest to forget. A cheaper model that raises the review rate is a false economy.

Why agent cost outruns the rate card

In that formula, requests is the term that grows. A re-reasoning agent reads the task, thinks it through, calls tools, answers, and keeps none of the reasoning. Tomorrow the same task arrives and the same tokens are spent again.

Take an inbound-request triage workflow. It reads a message, extracts a few fields, checks them against a rule set, writes a record and routes it to a queue. Field extraction is judgment. The rule check, the write and the routing are lookups and arithmetic, and paying $7.50 per million output tokens for arithmetic is overpaying. The rule check also does not improve by being re-derived each time. It just gets slower, less consistent and billable.

Move the deterministic share into code and the model's request count falls to the ambiguous cases. Cost is front-loaded, then flat: you pay reasoning tokens while the pattern is worked out, and after that volume grows against code, not inference. That is a property of the architecture, and it is the one lever on your bill that does not depend on a vendor's next price change.

Context is the second leak. A workflow that keeps its history in the prompt pays to refill that prompt on every run. A workflow that keeps state in a database reads it without tokens.

Build the triage workflow on Major

Major is the enterprise platform where agents build the software they run on. For a Mistral-backed workflow, that means the agent works out the repeatable steps once, builds an app for them, and runs the app from then on. Here is how the triage example maps.

1. Connectors. Gmail or Zendesk brings messages in, and Slack carries escalations out. Credentials are scoped per connector, so the agent holds only the access the workflow needs.
2. The app that holds state. The agent builds an app with a managed database for the classification taxonomy, routing table, processed-message log and escalation rules. History lives in tables, not in a context window.
3. The deterministic path. Deduplication, rule checks, record writes and queue routing run as code in the app. They produce the same result every time and cost compute, not tokens.
4. The judgment path. The agent calls the model only for messages the rules cannot resolve and for drafting replies that need real language skill. Batch mode fits the scheduled sweep, and cached prefixes fit the stable instructions.
5. Trigger. A schedule or connector event starts the run. A person sees every processed item in the app and can override a rule.
6. Governance. Role-based access controls who can change rules, and audit logs record every action the agent takes, so a finance or security reviewer can trace a routing decision.

The model does less. It does not do nothing, and the escalation path is where you most want a strong model. You can build and run the app yourself on Major.

Where a cheaper model is enough

Pick the cheapest model that clears your quality bar for the judgment calls that remain. Ministral at $0.10 per million tokens in and out handles classification and extraction well. Reserve Medium 3.5 for drafting that a customer will read. Once the lookups are in an app, that choice affects a small share of calls, so a mistake costs you much less than it does when every call goes through the model.

Start building on Major

If you are sizing a Mistral bill for a recurring workflow, separate the judgment calls from the lookups and build the app for the lookups on Major, with scoped connectors, a managed database and an audit trail.

• Start building free
• Book a demo

Related articles

• Enterprise AI Platforms: A Buyer’s Guide to Governed Agents
• Kimi K2 vs Claude: What Can Enterprise Agents Safely Delegate?
• Cheapest LLM API: Why the Lowest Token Price Rarely Wins