Mistral Large 4 API Setup: 13 Steps, $4.18/M Tokens [2026]

Mistral AI pushed a trillion-parameter model into public preview on October 6, 2026, and gave developers something unusual: same-day API access to a frontier-class system while the open weights are still three weeks out. Mistral Large 4, nicknamed “Le Chonk” in the company’s own announcement, is a 1 trillion-parameter mixture-of-experts model with 52 billion active parameters, a 1-million-token context window, and native multimodal input. If you want to call it from code today, the setup differs enough from earlier Mistral releases that old Large 3 snippets you may have bookmarked will not just work unchanged.

This tutorial walks through getting a working Mistral Large 4 API integration running in Python and TypeScript, from account creation to a complete working project, plus the pitfalls, errors, and migration steps that trip up developers moving from Large 3 or Large 2. Every step below reflects the model as it shipped in preview on La Plateforme as of October 2026, along with the self-hosting path you will need once Mistral publishes the weights later this month.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

What Is Mistral Large 4 (“Le Chonk”)?

Mistral Large 4 is a mixture-of-experts (MoE) model that Mistral AI trained from scratch over roughly two months on close to 4,000 Nvidia Grace Blackwell GPUs inside its own European data centers. The MoE design means the model stores about 1 trillion parameters but only activates around 52 billion per token, which keeps inference cost and latency closer to a mid-sized dense model than the raw parameter count suggests. A 1.6 billion-parameter vision encoder is bolted onto the main network, giving the model native image understanding rather than a separate captioning pass stitched on afterward.

Mistral’s launch material leads with cybersecurity numbers rather than the usual chat-assistant leaderboard: the company reports 93% on Cybench and 82% on CyberGym-E2E, benchmarks built from real security competition exercises and vulnerability reproduce-and-patch tasks. That framing matters for this tutorial because Mistral Large 4 is positioned, and priced, as an agentic and professional-work model first, not a general chatbot replacement. The API went live in preview on October 6, 2026, with the open weights scheduled for release by the end of the month, with different outlets citing dates between October 27 and October 31.

There is also a sovereignty angle behind the release that shapes how Mistral talks about the model. The training run spanned more than 160 languages, including every official language of the European Union, and ran entirely on Mistral’s own data center capacity in France and Sweden rather than rented US hyperscaler compute. For developers outside Europe, that detail is mostly background context. For teams building inside regulated European industries, government contracts, or any workload where data residency and vendor independence from US or Chinese infrastructure matters contractually, it is closer to the actual product pitch than the parameter count is.

Until the weights ship, the only way to run Mistral Large 4 is through Mistral’s hosted API on La Plateforme, also branded Mistral Studio in parts of the developer console. That is the workflow this guide covers in detail, with a separate section near the end on what to prepare before self-hosting becomes an option.

Prerequisites: What You Need Before You Start

• A Mistral AI account with billing enabled (a credit card is required to generate production API keys; a limited free trial credit is typically granted on signup)
• Python 3.9 or later, or Node.js 18 or later, depending on which SDK you plan to use
• The mistralai Python package (installed via pip) or the @mistralai/mistralai TypeScript/JavaScript package (installed via npm)
• A terminal with curl installed, for testing raw HTTP requests before wiring up SDK code
• Basic familiarity with environment variables for secrets management
• If you plan to send images, a file under the model’s documented upload size limit in JPEG, PNG, or WEBP format

One note before you begin: because Mistral Large 4 is still in preview, treat every pricing figure, rate limit, and the exact model identifier string as subject to change until Mistral’s general-availability announcement. The identifier used throughout this tutorial, mistral-large-4, is the string confirmed in Mistral’s own October 6 documentation, but preview-stage model IDs have shifted before at other labs, so check the live API reference before shipping production code against it.

Step 1: Create a Mistral AI Account and Access La Plateforme

Head to Mistral’s developer console at La Plateforme and sign up with a work email if you plan to use this for anything beyond a personal test. Mistral, like most model providers, applies basic fraud and abuse checks tied to email domains and phone verification, and a work email generally clears review faster than a disposable address. After verifying your email, you will land in the workspace selection screen.

If this is your first Mistral account, the console creates a default personal workspace automatically. If you are setting this up for a team, create a dedicated organization workspace instead so billing, usage dashboards, and API keys stay separated from personal experiments. This separation matters more than it sounds: Mistral Large 4’s preview pricing sits well above the company’s smaller Ministral and Medium model lines, so a stray personal test key left running in a shared Slackbot can generate a bill nobody expects.

Step 2: Generate and Secure Your API Key

Inside the workspace, open the API Keys section and create a new secret key. Give it a descriptive name, such as large4-tutorial-dev, rather than accepting the default label — this becomes important the moment you have more than one key active and need to figure out which one to revoke after a leak. Mistral displays the full key value exactly once at creation time.

Store the key as an environment variable rather than pasting it into source code:

export MISTRAL_API_KEY="your_api_key_here"

On Windows, use setx MISTRAL_API_KEY "your_api_key_here" in PowerShell, or add the variable through your project’s .env file with a loader library such as python-dotenv. Never commit a .env file containing a live key to version control, and add it to .gitignore before your first commit, not after.

Step 3: Install the Mistral SDK for Python or TypeScript

Mistral maintains official SDKs that wrap the REST API with typed request and response objects, automatic retries on transient failures, and streaming helpers. Install the one that matches your stack:

# Python
pip install mistralai

# TypeScript / JavaScript
npm install @mistralai/mistralai

If you would rather not add a dependency, every endpoint is reachable with plain HTTP requests, which is useful for quick testing with curl or for languages without an official SDK. The examples below cover both the SDK and the raw HTTP path so you can pick whichever fits your project.

Step 4: Make Your First API Call to Mistral Large 4

Start with a minimal call to confirm your key and environment are wired up correctly before building anything more complex. Here is the Python version using the official SDK:

import os
from mistralai import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-4",
    messages=[
        {"role": "user", "content": "Explain mixture-of-experts routing in two sentences."}
    ],
)

print(response.choices[0].message.content)

And the equivalent raw curl request, useful for debugging outside your application code:

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {"role": "user", "content": "Explain mixture-of-experts routing in two sentences."}
    ]
  }'

A successful response returns a JSON object with a choices array, token usage counts, and a finish_reason. If you get an authentication error here, double-check that your shell session actually exported the variable — a new terminal tab will not inherit it unless you re-export it or add it to your shell profile.

It is worth running this exact call two or three times in a row before moving on. Preview-stage endpoints occasionally return slightly different latency or an intermittent 503 under load, and catching that now, in a throwaway script, is far less painful than discovering it for the first time inside a half-built application three steps from now. If the first call succeeds cleanly, you have confirmed the three things most setup problems trace back to: a valid key, a reachable network path to Mistral’s API, and a correctly spelled model identifier.

Step 5: Understand Mistral Large 4 Pricing and Control Costs

Mistral Large 4’s preview API pricing is confirmed at $1.36 per million input tokens and $4.18 per million output tokens, well above Mistral’s smaller Ministral and Medium model lines, reflecting both the compute cost of serving a trillion-parameter MoE and the limited-access nature of a preview launch. The table below lines up the confirmed specs for budgeting purposes.

Spec	Mistral Large 4 (“Le Chonk”)
Total parameters	1 trillion
Active parameters per token	52 billion
Architecture	Mixture-of-experts, hybrid instruct + reasoning
Vision encoder	1.6 billion parameters, native multimodal
Context window	1,000,000 tokens
API model identifier	mistral-large-4
Preview input pricing	$1.36 per 1M tokens
Preview output pricing	$4.18 per 1M tokens
Open weights release	Planned late October 2026 (reports vary between Oct. 27 and Oct. 31)

A 50-page document at roughly 25,000 tokens, summarized into a 500-token response, costs about 3.4 cents on input and 0.2 cents on output at these rates — small per call, but it adds up quickly once you are routinely filling a large portion of a 1-million-token context window. Set a monthly spend limit in the billing dashboard before you start load-testing, and watch the usage field returned on every response so your application can log cost per request from day one rather than retrofitting cost tracking later.

Step 6: Send Multimodal Image-and-Text Requests

Mistral Large 4 ships natively multimodal, meaning the same model handles text and images without routing to a separate vision model behind the scenes. To send an image alongside a text prompt, pass a content array mixing a text block and an image block, either as a URL or as base64-encoded data:

import base64

with open("incident_screenshot.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.complete(
    model="mistral-large-4",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What error is shown in this screenshot, and what's the likely cause?"},
                {"type": "image_url", "image_url": f"data:image/png;base64,{image_b64}"}
            ]
        }
    ],
)

print(response.choices[0].message.content)

Base64-encoding large images inflates the request payload by roughly a third, so for production workloads where the image already lives in cloud storage, pass a signed URL in the image_url field instead of inlining the bytes. This keeps request sizes smaller and avoids hitting payload limits on images in the multi-megabyte range.

Step 7: Work With the 1-Million-Token Context Window

A context window this large changes how you should architect retrieval. Instead of chunking a document into small passages and running a vector search to find the three most relevant paragraphs, it is often simpler and more accurate to paste the entire source document directly into the prompt, provided it fits comfortably under the token limit with room left for the response.

That said, a 1-million-token window does not mean every token receives equal attention from the model. Place your actual instructions and the specific question you want answered near the end of the prompt, after the reference material, rather than burying them in the middle of a long document. This ordering consistently produces better-grounded answers across large-context models and is worth testing explicitly against your own documents before committing to a prompt structure in production.

Step 8: Stream Responses for Real-Time Output

For anything user-facing, streaming tokens as they are generated avoids making users stare at a blank screen while a long response is produced. The Python SDK exposes a dedicated streaming method:

stream = client.chat.stream(
    model="mistral-large-4",
    messages=[
        {"role": "user", "content": "Write a three-paragraph summary of mixture-of-experts architectures."}
    ],
)

for chunk in stream:
    delta = chunk.data.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

If you are building a web backend, pipe this generator directly into a server-sent events (SSE) response rather than buffering the full output server-side first. Buffering defeats the entire purpose of streaming and just moves the latency from the model provider to your own server.

Choosing Between Mistral Large 4, Medium, and Ministral

Not every call in your application needs a trillion-parameter MoE model behind it, and routing everything through Large 4 by default is one of the fastest ways to inflate a bill without improving results. Mistral’s lineup is built around a tiered approach: Ministral for small, fast, cheap classification and routing tasks; Medium for everyday chat, summarization, and general-purpose work; and Large 4 for the workloads that actually benefit from frontier-level reasoning, agentic tool use, long-document analysis, or image understanding.

• Use Ministral for intent classification, short extraction tasks, moderation checks, or any high-volume call where latency and per-call cost matter more than reasoning depth.
• Use Medium for general chatbots, customer support drafting, and summarization where the input is a few thousand tokens, not a full codebase or a 200-page filing.
• Use Large 4 for multi-step agentic workflows, security and compliance analysis, large-document review that benefits from the 1-million-token window, or any task where you have already benchmarked a smaller model and found its output quality insufficient.

A practical pattern many teams land on is a router step at the front of the pipeline: a cheap Ministral call classifies incoming requests by complexity, and only the subset that actually needs deep reasoning gets forwarded to Large 4. This keeps average cost per request low while still giving the hard cases access to the strongest model in the lineup.

Adding Function Calling and Tool Use

Mistral Large 4’s cybersecurity and agentic positioning assumes it will frequently be calling external tools rather than just generating text. The chat completion endpoint accepts a tools parameter describing available functions, and the model decides when to invoke one instead of answering directly:

tools = [
    {
        "type": "function",
        "function": {
            "name": "lookup_cve",
            "description": "Look up details for a CVE identifier",
            "parameters": {
                "type": "object",
                "properties": {
                    "cve_id": {"type": "string", "description": "e.g. CVE-2026-12345"}
                },
                "required": ["cve_id"],
            },
        },
    }
]

response = client.chat.complete(
    model="mistral-large-4",
    messages=[{"role": "user", "content": "What is CVE-2026-12345 and how severe is it?"}],
    tools=tools,
    tool_choice="auto",
)

tool_calls = response.choices[0].message.tool_calls
if tool_calls:
    for call in tool_calls:
        print(call.function.name, call.function.arguments)

When the model returns a tool_calls entry instead of a direct answer, your application is responsible for executing the actual function, then sending the result back as a follow-up message with the tool role so the model can incorporate it into a final response. Cap the number of tool-call round trips per conversation turn; an agent loop with no ceiling is the most common way a cybersecurity-flavored agent ends up burning through tokens on a task that should have taken two calls, not twenty.

Step 9: Build a Complete Working Project — a Compliance Document Analyzer

With the basics in place, here is a complete, runnable script that ties together several of the steps above: it reads a document, sends it with a structured instruction, and returns a flagged summary. This is representative of the kind of professional-work task Mistral is positioning Large 4 for.

import os
import sys
from mistralai import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

SYSTEM_PROMPT = """You are a compliance document analyzer. Given a document,
identify: 1) any dates with deadlines, 2) any named regulations or statutes
referenced, 3) any sections that appear incomplete or contradictory.
Respond in three clearly labeled sections. Be concise."""

def analyze_document(path: str) -> str:
    with open(path, "r", encoding="utf-8") as f:
        document_text = f.read()

    response = client.chat.complete(
        model="mistral-large-4",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": document_text},
        ],
        temperature=0.2,
    )

    usage = response.usage
    print(f"[tokens] input={usage.prompt_tokens} output={usage.completion_tokens}", file=sys.stderr)

    return response.choices[0].message.content

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python analyzer.py ")
        sys.exit(1)

    result = analyze_document(sys.argv[1])
    print(result)

Run it with python analyzer.py contract.txt. The temperature=0.2 setting keeps the output consistent across repeated runs on the same document, which matters for a compliance-adjacent task where you want reproducible flags rather than creative variation. Swap the system prompt for your own domain — incident report triage, contract redlining, log analysis — and the same scaffolding carries over directly.

Step 10: Handle Errors, Retries, and Rate Limits

Production code needs to handle three categories of failure: authentication errors (bad or revoked key), rate limiting (HTTP 429), and transient server errors (HTTP 5xx). Wrap calls in retry logic with exponential backoff rather than retrying immediately in a tight loop, which only makes rate limiting worse:

import time
from mistralai.models import SDKError

def call_with_retry(client, max_attempts=4, **kwargs):
    for attempt in range(max_attempts):
        try:
            return client.chat.complete(**kwargs)
        except SDKError as e:
            if getattr(e, "status_code", None) == 429 and attempt < max_attempts - 1:
                wait = 2 ** attempt
                time.sleep(wait)
                continue
            raise
    raise RuntimeError("Exceeded max retry attempts")

Because Mistral Large 4 is in preview, expect rate limits to be tighter than on established model lines and subject to change without much notice. Log every 429 response with a timestamp during your first week of integration so you have real data on your effective throughput ceiling instead of guessing from documentation that may lag the actual preview-stage limits.

Step 11: Migrate Existing Code From Mistral Large 3 or Large 2

If you already have an integration pointed at mistral-large-3 or an earlier Large model, the migration is deliberately shallow for a basic chat completion call: swap the model string and re-test.

# Before
response = client.chat.complete(model="mistral-large-3", messages=messages)

# After
response = client.chat.complete(model="mistral-large-4", messages=messages)

What is not a one-line change: Mistral Large 3 shipped under an Apache 2.0 license as an open-weight model, while Mistral has not yet published the license terms for Large 4's eventual weights release. If your deployment or legal review depends specifically on Apache 2.0 terms, do not assume Large 4 will inherit the same license until Mistral confirms it alongside the weights drop. Budget-sensitive teams should also re-run cost projections, since Large 4's preview pricing sits meaningfully above Large 3's published rates, reflecting the larger active-parameter count and preview-stage scarcity pricing.

Step 12: Prepare for the Open-Weights Release and Self-Hosting

Mistral has said it will publish Large 4's weights by the end of October 2026, after additional safety testing, with cybersecurity experts and government authorities getting earlier access to a version with fewer safety restrictions for evaluation purposes. Once weights are public, self-hosting a 1.05-trillion-parameter MoE model is a different scale of problem than running the smaller open models most teams are used to.

Even though only 49 billion parameters activate per token, most inference setups still need to keep all experts resident in memory, since the router can send any given token to any expert. A rough, uncompressed storage estimate for a 1.05-trillion-parameter model is in the neighborhood of 2 petabytes at 16-bit precision, dropping to roughly half a petabyte at 4-bit quantization — figures that make single-GPU or even single-node self-hosting unrealistic for the vast majority of teams. Plan on a multi-node GPU cluster with tensor and expert parallelism, and treat the hosted API as your production path unless you already operate infrastructure at that scale. Mistral has not yet published an official inference-hardware guide for Large 4, so treat any third-party VRAM estimate, including the one above, as a planning approximation rather than a confirmed requirement until Mistral's own deployment documentation ships alongside the weights.

Realistically, the teams best positioned to self-host Large 4 on day one of the weights release are the same ones who already run inference clusters for other trillion-parameter-class open models like DeepSeek V4 Pro or Qwen3.8 Max, since the tooling (vLLM, SGLang, or similar expert-parallel inference engines) tends to need only configuration changes rather than a ground-up rebuild to support a new MoE checkpoint. If that is not your team, it is worth budgeting for a few weeks of lag between the weights landing and a stable, cost-effective self-hosted deployment, and continuing to run production traffic through the API in the meantime rather than racing to cut over on release day.

Step 13: Monitor Usage and Set Up Production Guardrails

Before pointing real user traffic at Large 4, add three guardrails that are easy to skip during a proof-of-concept but expensive to retrofit later. First, log token usage per request to a time-series store so you can graph cost trends and catch a runaway prompt-construction bug before it becomes a surprise invoice. Second, set a hard per-request token cap on both input and output, independent of the model's own context limit, so a malformed loop in your own code cannot send a 900,000-token prompt by accident. Third, add a circuit breaker that falls back to a smaller, cheaper Mistral model, or a cached response, if Large 4's preview endpoint returns sustained 5xx errors, since preview-stage infrastructure is more likely to have rough edges than a model that has been generally available for months.

Common Pitfalls When Setting Up Mistral Large 4

• Assuming the model ID is final. Preview-stage identifiers have changed at other labs between preview and general availability. Pin your dependency and model string, and watch Mistral's changelog before any production deploy.
• Treating "open-weight" as "already downloadable." Mistral's own announcement describes Large 4 as an open-weight model, but the weights themselves were not shipping on day one. The only access path at launch is the hosted API, which somewhat undercuts the open-weight framing in the short term.
• Base64-encoding every image by default. Inlining image bytes bloats request payloads and can push you toward payload size limits faster than expected. Use signed URLs for anything beyond small thumbnails.
• Ignoring preview pricing volatility. Preview pricing on frontier model launches has shifted after general availability at multiple labs this year. Do not bake a specific per-token rate into a customer-facing price calculator without a buffer.
• Carrying over Large 3's license assumptions. Large 3 was Apache 2.0; Large 4's weight license has not been published. Do not represent Large 4 as Apache-licensed in your own documentation until Mistral confirms it.
• Skipping retry logic because "the demo worked fine." Preview endpoints see uneven traffic and are more prone to transient errors than mature, generally available models. Code that works in a five-minute demo will surface rate-limit and timeout edge cases within a day of real traffic.

Troubleshooting Guide: Common Errors and Fixes

Symptom	Likely Cause	Fix
HTTP 401 Unauthorized	Key not exported in current shell, or key revoked	Re-export MISTRAL_API_KEY in the active terminal session; generate a new key if revoked
HTTP 429 Too Many Requests	Preview-stage rate limit hit	Add exponential backoff; request a rate-limit increase from Mistral support if sustained
Model not found / invalid model string	Using an outdated or mistyped model ID	Confirm current ID against Mistral's live API reference; preview IDs can change
Image request silently ignored	Malformed content array or unsupported image format	Verify the content field is an array of typed blocks, not a flat string; use JPEG, PNG, or WEBP
Response is cut off mid-sentence	Output token limit reached before completion	Raise max_tokens, or ask for a shorter response explicitly in the prompt
Streaming connection drops early	Client-side timeout shorter than generation time	Increase HTTP client timeout settings; long documents can take well over 30 seconds to fully stream
Inconsistent answers across identical calls	Default temperature allows sampling variance	Set temperature close to 0 for deterministic, repeatable tasks
Unexpectedly high monthly bill	No per-request token cap; large documents sent in full repeatedly	Add hard token caps and cache repeated document analyses instead of re-sending

Mistral Large 4 vs GPT-6.1 Sol vs Claude Sonnet 5.5 vs DeepSeek V4 Pro

Mistral is explicit that it is benchmarking Large 4 against the open-weight Chinese frontier rather than solely against closed US labs, but developers choosing an API for a new project are usually comparing across all of them at once. The table below lines up what is publicly confirmed as of mid-October 2026. Treat the benchmark-driven claims as company-reported figures rather than independently reproduced scores, since full third-party verification across all four systems was not yet available at publication time.

Model	Total / Active Params	Context Window	Input / Output Price per 1M Tokens	Weights
Mistral Large 4 ("Le Chonk")	1.05T / 49B	1,000,000 tokens	$1.36 / $4.18 (preview)	Open weights planned late Oct. 2026
OpenAI GPT-6.1 Sol	Undisclosed	1,050,000 tokens	$2.00 / $10.00	Closed, API-only
Claude Sonnet 5.5	Undisclosed	Undisclosed (large context tier)	$2.00 / $10.00	Closed, API-only
DeepSeek V4 Pro	1.65T / 49B	Large context tier	Lower-cost open-weight pricing	Open weights available since Aug. 2026

The headline comparison Mistral wants developers to take away is cost: Large 4's preview input price undercuts both GPT-6.1 Sol and Claude Sonnet 5.5 on paper, while matching DeepSeek V4 Pro's active-parameter footprint almost exactly at 49 billion. Whether that translates into better results for your specific workload depends heavily on the task. Mistral's own reported numbers show Large 4 ahead of GPT-6 Astra on visual grounding (DIOR-RSVG) and ahead of Kimi K3 on a legal-agent benchmark, but narrower margins against Qwen3.8 Max and DeepSeek V4 Pro on general coding-agent indices. Run your own task-specific evaluation before committing a production workload to any single vendor, rather than relying on a single aggregate leaderboard number.

One practical difference the table does not fully capture is availability of weights. DeepSeek V4 Pro's weights have already been downloadable since August 2026, meaning teams with the infrastructure to self-host it can run it today at compute cost rather than per-token API pricing. GPT-6.1 Sol and Claude Sonnet 5.5 are, and are expected to remain, API-only with no self-hosting path at all. Mistral Large 4 sits in between: closed for now, open by the end of October, which makes it the only model in this table where the deployment model itself is scheduled to change under you within the same month you start building against it.

Advanced Tips for Production Deployments

Once the basic integration is stable, a few practical adjustments make a measurable difference at scale. First, use prompt caching where available: Mistral's documentation lists a cached-input rate roughly 95% below the standard input price, which matters enormously for workflows that repeatedly send the same long system prompt or reference document with only the final user question changing. Structure your prompts so the stable, reusable portion comes first and the variable portion comes last, since caching works on the shared prefix.

Second, do not default every request to the full 1-million-token context just because it is available. Longer contexts cost more, add latency, and in practice do not always improve answer quality over a well-curated shorter prompt. Reserve the full window for genuinely document-heavy tasks, and keep routine chat-style interactions lean.

Third, since Large 4 is explicitly positioned for agentic and tool-using workflows, test any multi-step agent loop you build against a hard iteration cap and a timeout, independent of whatever safeguards the model itself has. A model that is good at chaining tool calls is also a model that can, under a bad prompt or a buggy tool response, loop longer than intended and burn through tokens unattended.

Finally, keep a fallback model configured in your application layer. Because Large 4 is still in preview, build your abstraction layer so swapping to a different Mistral model, or a different provider entirely, is a configuration change rather than a code change. This is standard practice for any preview-stage API integration, and it pays off the first time a provider has an unplanned outage during business hours.

It also helps to separate your evaluation harness from your production prompts early. Keep a small, versioned set of representative test cases — a handful of real documents, a few agentic tool-use scenarios, a couple of image-understanding examples — and re-run them every time you change a prompt, bump an SDK version, or notice Mistral has pushed a preview update. Preview-stage models can shift behavior between point releases more than generally available ones do, and a lightweight regression suite catches a quality drop long before your users do.

Frequently Asked Questions

Is Mistral Large 4 free to use?

No. Mistral Large 4 requires a paid API key with billing enabled on La Plateforme. New accounts typically receive a small trial credit, but sustained use requires an active payment method and incurs charges at the published per-token rate.

What is the exact model ID to use in API calls?

Use mistral-large-4 as the model string in both the Python and TypeScript SDKs, as well as in raw HTTP requests. This is the identifier confirmed in Mistral's own documentation at the October 6, 2026 preview launch, though preview-stage model names can change before general availability.

Can I download and self-host Mistral Large 4 today?

Not yet. At launch, Mistral Large 4 is only accessible through the hosted API on La Plateforme. Mistral has said it plans to publish the open weights by the end of October 2026, after additional safety testing, with reports citing dates between October 27 and October 31.

Will Mistral Large 4 be released under the Apache 2.0 license like Large 3?

That has not been confirmed. Mistral Large 3 shipped under Apache 2.0, but Mistral has not yet published the license terms for Large 4's weights. Do not assume the same license applies until Mistral confirms it alongside the weights release.

Does Mistral Large 4 support images, or only text?

Mistral Large 4 is natively multimodal and ships with a dedicated 1.6 billion-parameter vision encoder, so it accepts both text and image input in the same request without routing to a separate model.

How does Mistral Large 4's pricing compare to GPT-6.1 Sol or Claude Sonnet 5.5?

At preview pricing, Mistral Large 4 costs $1.36 per million input tokens and $4.18 per million output tokens, below OpenAI's GPT-6.1 Sol and Anthropic's Claude Sonnet 5.5, which are both listed at $2.00 per million input tokens and $10.00 per million output tokens. Preview pricing can change at general availability, so confirm current rates before budgeting a production workload.

What hardware would I need to self-host Mistral Large 4 once weights are released?

Mistral has not published an official hardware guide yet. As a rough planning estimate, a 1.05-trillion-parameter model needs roughly 2 petabytes of memory at 16-bit precision, or about half a petabyte at 4-bit quantization, which realistically requires a multi-node GPU cluster with tensor and expert parallelism rather than a single workstation or server.

Does migrating from Mistral Large 3 to Large 4 require code changes beyond the model string?

For basic chat completions, changing the model string is usually enough. But re-check your license assumptions, since Large 4's weight license is unconfirmed, and re-run cost projections, since Large 4's preview pricing sits above Large 3's published rates.

Related Coverage

• Claude Opus 5.5 API Setup: 13 Steps, $4/$20 per 1M [2026]
• Claude Sonnet 5.5 API Setup: 13 Steps, $2/$10 per 1M [2026]
• Bing Image Creator Setup: 12 Steps, 15 Free a Day [2026]
• Z-Image Turbo Setup: 6B Params, 14 Steps [2026]
• Nano Banana vs GPT Image API: 13-Step AI Benchmark [2026]