Mistral: Mistral Small 4 (batch)
Mistral Small 4 is the next major release in the Mistral Small family, unifying the capabilities of several flagship Mistral models into a single system. It combines strong reasoning from...
Anyone in the Project can @-mention Mistral: Mistral Small 4 (batch) with the team's shared context - pooled credits, one chat, one memory.
Starter is free forever - 1 Project, 100 credits/month, 1 MCP. No card.
Verdict
Best for
- Overnight batch document classification
- High-volume content moderation queues
- Cost-sensitive data extraction pipelines
- Bulk summarization of support tickets
- Large-scale sentiment analysis jobs
Strengths
The pricing is the headline: $0.07 input makes this one of the cheapest ways to process large text volumes at scale. The 262K context window means you can feed entire reports, legal documents, or multi-chapter content without splitting. Batch processing architecture lets you queue thousands of requests and walk away, ideal for overnight ETL jobs or weekly content audits. Image input support adds flexibility for document analysis tasks involving screenshots or scanned pages.
Trade-offs
Batch-only processing means latency measured in minutes or hours, not seconds—this isn't for user-facing features. Reasoning capability lags behind Mistral Large or Claude Sonnet on complex multi-step tasks; expect weaker performance on math, code debugging, or nuanced analysis. No public benchmarks yet make it hard to validate claims against peers. The 'Small' designation suggests reduced parameter count, which typically means less world knowledge and more hallucination risk on edge cases.
Specifications
- Provider
- mistralai
- Category
- llm
- Context length
- 262,144 tokens
- Max output
- 209,715 tokens
- Modalities
- text, image
- License
- proprietary
- Released
- 2026-03-16
Pricing
- Input
- $0.07/Mtok
- Output
- $0.30/Mtok
- Model ID
mistralai/mistral-small-2603:batch
Per-token prices show what the model costs upstream. On Switchy your team draws from one shared org credit pool - one plan, one balance for everyone.
Team cost calculator
5 seats · 80 msgs/day
Switchy meters this against your org's shared credit pool - one plan, one balance for everyone.
Providers
| Provider | Context | Input | Output | P50 latency | Throughput | 30d uptime |
|---|---|---|---|---|---|---|
| mistralai | 262k | $0.07/Mtok | $0.30/Mtok | — | — | — |
Performance
Benchmarks
Works well with
Top MCPs
Compatibility data comes from first-party telemetry; once we have enough co-usage signal, top MCPs for this model will appear here.
How Switchy teams use it
Starter prompts
Classify Support Tickets
Read this support ticket and classify it into exactly one category: Billing, Technical, Account, Shipping, or Other. Return only the category name. Ticket: [paste ticket text here]
Extract Invoice Data
Extract the following fields from this invoice: vendor name, invoice number, date, total amount, and line items with quantities. Return as JSON.
Summarize Long Reports
Summarize this report in 150 words or less. Focus on key findings, recommendations, and any action items. Maintain a neutral tone.
Moderate User Content
Review this user comment for policy violations: hate speech, spam, personal attacks, or explicit content. Respond with 'APPROVED' or 'FLAGGED: [reason]'. Comment: [paste comment here]
Batch Sentiment Analysis
Rate the sentiment of this text as Positive, Neutral, or Negative. Then provide a confidence score from 0-100. Text: [paste text here]
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
Review this Python function for potential bugs. Focus on edge cases around empty inputs and type mismatches: ```python def merge_configs(base, override): result = base.copy() for key, value in override.items(): if key in result and isinstance(result[key], dict): result[key] = merge_configs(result[key], value) else: result[key] = value return result ```
This recursive merge function has three issues worth addressing. First, it doesn't validate that `override` is a dictionary before calling `.items()`, which will raise AttributeError if passed None or a non-dict. Second, the recursive call assumes `value` is also a dict when `result[key]` is a dict, but doesn't verify this—passing `{"a": {"b": 1}}` as base and `{"a": "string"}` as override will crash. Third, the function mutates the input via `.copy()` which is shallow—nested dicts share references with the original. Consider adding type guards at the function entry and before the recursive call, and use `deepcopy` if full immutability is required.
Mistral Small 4's 262K context window allows pasting entire codebases for review, making it practical for architectural analysis beyond single-function checks. The batch pricing ($0.07 input) makes it economical for bulk code audits. However, without public benchmarks, we can't verify its accuracy against HumanEval or similar coding tests—teams should validate outputs on their specific codebase patterns.
I have a product photo of a ceramic mug on a white background. Describe three different lifestyle scene compositions I could create around it for an e-commerce hero image, each targeting a different customer mood.
For a cozy-morning mood: place the mug on a wooden breakfast tray with a folded linen napkin, a small plate with croissant crumbs, and soft window light from the left creating gentle shadows. The mug should be slightly off-center with steam implied by the lighting warmth. For a minimalist-focus mood: position the mug on a concrete or marble surface with a single succulent in a small pot nearby, shot from directly above with hard shadows at 45 degrees—clean, geometric, aspirational. For a creative-workspace mood: nestle the mug among scattered design tools—a sketchbook with visible pencil marks, a few Pantone swatches, a mechanical pencil—shot at table height with shallow depth of field so the mug stays sharp while the background tools blur into context.
The multimodal input capability lets users upload reference images alongside text prompts, useful for design briefs that need visual context. At $0.30/Mtok output, longer creative descriptions remain affordable for batch processing multiple product SKUs. The model handles compositional reasoning well, though without image generation capability itself, this serves planning workflows rather than direct asset creation.
Summarize the key regulatory changes in this 47-page EU AI Act compliance document, focusing specifically on obligations for general-purpose AI providers. Prioritize information relevant to model deployment timelines and transparency requirements.
General-purpose AI providers face three primary obligation tiers under the Act. First, transparency mandates require publishing technical documentation detailing training data sources, compute resources used, and known limitations—due within 6 months of the Act's entry into force for existing models. Second, for high-impact models (>10^25 FLOPs training compute), additional systemic risk assessments and adversarial testing reports must be filed annually with the AI Office, with the first cycle beginning 12 months post-enforcement. Third, all providers must implement content provenance mechanisms (watermarking or metadata tagging) for generated outputs by the 18-month mark. Penalties scale from 1.5% to 7% of global annual turnover depending on violation severity. The document notes a grace period for models released before 2024 Q3, allowing 24 months for full compliance retrofitting.
The 262K token context window is the standout feature here—it comfortably ingests lengthy regulatory documents, technical specifications, or research papers that would require chunking in smaller models. Batch pricing makes document analysis workflows cost-effective at scale. The model's ability to extract structured information and prioritize by user-specified criteria is solid, though legal teams should still verify citations against source material for compliance-critical work.
Use-case deep-dives
Why Mistral Small 4 batch wins for end-of-month invoice runs
A 12-person accounting firm processes 800-1,200 vendor invoices at month-end, extracting line items into QuickBooks. Mistral Small 4 batch is the right call here: $0.07/Mtok input means you're paying roughly $0.14 per 100 invoices (assuming 20k tokens per batch), and the 262k context window lets you pack 40-50 invoices per request without chunking. The batch endpoint trades latency for cost—jobs complete in 2-6 hours, which is fine when you're running overnight. If you need same-day turnaround or real-time extraction during client calls, switch to the standard endpoint or a faster model. For monthly batch workflows where you can queue the work and wait, this is the cheapest way to handle structured extraction at scale.
When Mistral Small 4 batch handles overnight ticket classification
A 20-person SaaS company gets 300-500 support tickets daily and wants to auto-tag them (bug/feature/billing) before the morning shift. Mistral Small 4 batch works if you're comfortable with a 4-8 hour processing window: queue all overnight tickets at 11pm, get classifications by 7am, and route them before the team logs in. At $0.07 input, you're spending under $2/day even with verbose ticket histories. The 262k context window means you can include the last 10 customer interactions for better classification. The trade-off: if you need real-time triage during business hours—tagging tickets as they arrive—batch latency kills the workflow. For overnight preprocessing where morning delivery is good enough, this is the most cost-effective option in the Mistral lineup.
Why Mistral Small 4 batch fits weekly content calendar builds
A 4-person marketing team generates 30-40 social posts and email drafts every Monday for the week ahead. Mistral Small 4 batch is the right tool: you submit the week's brief on Sunday night, get all drafts by Monday morning, and spend the day editing instead of prompting. At $0.30/Mtok output, 40 drafts (averaging 300 words each) cost roughly $0.36—cheap enough to regenerate variants without budget anxiety. The image input modality also means you can include brand screenshots or product mockups in the prompt for more on-brand output. If your workflow is daily or real-time (reacting to news, posting within the hour), batch latency breaks the loop. For weekly planning cycles where you can batch-generate and human-edit, this is the lowest-cost way to scale content production.
Frequently asked
Is Mistral Small 4 good for batch text processing?
Yes, it's designed for batch workloads where latency doesn't matter. With a 262k context window, you can process long documents or multiple items in one call. The batch endpoint trades speed for cost—expect minutes of delay but significantly lower pricing than real-time alternatives. Best for overnight jobs, data pipelines, or bulk content analysis.
Is Mistral Small 4 cheaper than GPT-4o mini for batch jobs?
No. At $0.07 input and $0.30 output per Mtok, Mistral Small 4 costs more than GPT-4o mini's batch pricing ($0.05/$0.15). You're paying roughly 40-100% more depending on your input/output ratio. Unless you need the 262k context window or prefer Mistral's European data residency, GPT-4o mini batch is the better value.
Can Mistral Small 4 handle image inputs reliably?
The model lists image support, but without public benchmarks we can't verify quality. Mistral's vision capabilities historically lag OpenAI and Anthropic. If image understanding is critical—OCR, diagram analysis, visual reasoning—test thoroughly before committing. For text-only batch work, you're on safer ground.
How does Mistral Small 4 compare to previous Mistral Small versions?
We don't have benchmark data to confirm improvements over Mistral Small 3. The 262k context window is standard for recent Mistral releases. Pricing appears consistent with their small-tier models. Without performance metrics, assume incremental updates rather than a major capability jump. Request sample outputs for your use case before migrating.
Should I use Mistral Small 4 for daily report generation?
Only if you can tolerate batch delays. Reports that need to run overnight or early morning work fine—submit at 11pm, get results by 6am. For anything user-facing or time-sensitive, use a real-time endpoint instead. The cost savings don't justify frustrated users waiting minutes for output.
Compare with
More language models
- Mistral: Mixtral 8x22B Instructmistralai
- Mistral: Sabamistralai
- Mistral: Voxtral Small 24B 2507mistralai
- Moondream: Moondream 3.1moondream
- Moondream: Moondream 3 Previewmoondream
- MoonshotAI: Kimi K2 0711moonshotai
- MoonshotAI: Kimi K2 0905moonshotai
- MoonshotAI: Kimi K2.5moonshotai
- MoonshotAI: Kimi K2.6moonshotai
- MoonshotAI: Kimi K2.7 Codemoonshotai
- MoonshotAI: Kimi K2 Thinkingmoonshotai
- MoonshotAI: Kimi K3moonshotai