De MiniMax M3 API gebruiken

TLDR MiniMax M3 combineert een contextvenster van 1.000.000 tokens, native tekst-beeld-video begrip, sterke codeer- en agentprestaties, en MiniMax Sparse Attention (MSA). Ontwikkelaars kunnen MiniMax M3 aanroepen via CometAPI’s OpenAI-compatibele gateway op https://api.cometapi.com/v1 met model-ID minimax-m3.

Deze gids behandelt de specificaties van het model, officiële benchmarkgegevens, API-setup, streaming, reasoning-controls, multimodale verzoeken, tool-calling, prijzen en vergelijkingen met andere frontier-API’s in 2026.

Belangrijkste punten

• MiniMax M3 ondersteunt tot 1M tokens context, wat coderen op repository-schaal en langlopende agentsessies mogelijk maakt.
• Het model is natively multimodaal vanaf trainingsstap nul en accepteert tekst-, beeld- en videoinvoer.
• De MiniMax Sparse Attention-architectuur is ontworpen om contexten van een miljoen tokens computationeel praktischer te maken. Officiële resultaten omvatten 59,0% op SWE-Bench Pro en 66,0% op Terminal-Bench 2.1, naast sterke agent- en tool-use scores.
• MiniMax’s OpenAI-compatibele API ondersteunt adaptief of uitgeschakeld denken, streaming, tools en reasoning_split.
• Op CometAPI is de huidige model-ID minimax-m3 en is het hoofdendpoint /v1/chat/completions.

Wat is MiniMax M3?

MiniMax M3 is ontworpen rond drie workloads die ontwikkelaarsmodellen aan de frontier steeds meer definiëren: grootschalige software-engineering, autonome agent-executie en multimodaal long-context redeneren. MiniMax omschrijft M3 als een model dat frontier-niveau prestaties behaalt op coderings- en agenttaken, terwijl het 1M context, native multimodaliteit en MSA combineert. Het praktische resultaat is een model dat minder is gericht op geïsoleerde chatbeurten en meer op workflows die in de loop van de tijd bestanden, toolresultaten, screenshots, codewijzigingen en redeneringsstatus accumuleren.

M3 is beschikbaar via MiniMax’s eigen API-ecosysteem en via CometAPI’s MiniMax M3-endpoint. Voor ontwikkelaars die al de OpenAI SDK gebruiken, houdt de CometAPI-route de vertrouwde Chat Completions-vorm aan, terwijl het vergelijken van M3 met modellen van Anthropic, Google, Moonshot AI en andere providers eenvoudiger wordt.

Technische specificaties van MiniMax M3

De context- en modaliteitscijfers hierboven zijn bevestigd in MiniMax’s API-documentatie, terwijl de modelarchitectuur en releasepositionering afkomstig zijn van de officiële M3-release.

Wat maakt MiniMax M3 anders?

MiniMax Sparse Attention en 1M-context

Een contextvenster van een miljoen tokens is alleen nuttig als de serving-architectuur het kan verwerken met acceptabele snelheid en kosten. M3 pakt dat probleem aan met MiniMax Sparse Attention (MSA), dat eerst relevante KV-blokken identificeert en vervolgens sparse attention uitvoert over geselecteerde regio’s in plaats van overal volledige kwadratische attention toe te passen.

MiniMax meldt dat M3 bij een contextlengte van 1M ongeveer 1/20 van de per-token compute van de vorige generatie gebruikt, met meer dan 9x snellere prefill en meer dan 15x snellere decoding. Dit zijn door de leverancier gerapporteerde engineeringresultaten in plaats van metingen door derden, maar ze verklaren waarom MSA centraal staat in M3’s long-context ontwerp.

Figuur 1. MiniMax Sparse Attention-architectuur. Bron: MiniMax officiële M3-release

Native multimodaliteit

MiniMax zegt dat M3 gemengde modaliteiten vanaf stap nul in training heeft ondergaan, in plaats van een aparte visionlaag toe te voegen na tekst-pretraining. In de OpenAI-compatibele API accepteert M3 tekst-, beeld- en videocontentdelen. Afbeeldingen kunnen worden geleverd met image_url en video’s met video_url; ondersteunde afbeeldingsformaten zijn JPEG, PNG, GIF en WEBP, terwijl ondersteunde videoformaten MP4, AVI, MOV en MKV zijn.

Voor ontwikkelaars maakt dat één model bruikbaar voor taken zoals debuggen op basis van screenshots, grafiekinterpretatie, UI-review, technische-documentanalyse en videobegrip zonder dat elke visuele invoer via een apart model moet worden gerouteerd.

Coding- en agent-workflows

M3’s sterkste publieke positionering is niet generieke chat. MiniMax richt zich op bugfixing, frontend- en backendontwikkeling, terminaluitvoering, prestatieoptimalisatie, toolaanroepen en samenwerking op lange termijn. De officiële M3-benchmarkset benadrukt daarom software-engineering- en agentbenchmarks in plaats van alleen academische QA-tests.

Configureerbaar redeneren

In MiniMax’s OpenAI-compatibele API ondersteunt M3 expliciete redeneringscontrole: denken kan worden ingesteld op adaptief of uitgeschakeld. Als het veld wordt weggelaten op MiniMax’s OpenAI-compatibele endpoint, staat denken standaard aan. Voor productie-integraties is het veiliger om het veld expliciet in te stellen, omdat dit latency en gedrag gemakkelijker reproduceerbaar maakt tussen omgevingen.

Langetermijnprestaties van agents

MiniMax publiceerde ook twee langlopende casestudies die laten zien waarom M3’s contextontwerp ertoe doet. In een paper-reproductietaak draaide M3 autonoom bijna 12 uur, met 18 commits en 23 experimentele figuren terwijl het de kernexperimenten van een ICLR 2025 Outstanding Paper reproduceerde. De taak vereiste het lezen van figuren en formules, het bewerken van code, het volgen van experimenten en het behouden van een lange uitvoeringsgeschiedenis.

In een aparte oefening voor CUDA-kerneloptimalisatie meldt MiniMax 147 benchmarkinzendingen en 1.959 toolaanroepen over ongeveer 24 uur, waarbij de piekbenutting van Hopper FP8-hardware steeg van 7,6% naar 71,3%, wat gelijk staat aan een gerapporteerde 9,4x versnelling. Deze voorbeelden zijn gecontroleerde demonstraties in plaats van garanties voor elke productieagent, maar ze illustreren de beoogde use case: persistente toolloops waarbij voortgang mogelijk pas na vele iteraties zichtbaar wordt.

Waarom de MiniMax M3 API via CometAPI gebruiken?

CometAPI stelt M3 bloot via dezelfde algemene API-omgeving die wordt gebruikt voor honderden andere modellen. Dat is belangrijk wanneer een team meerdere providers wil benchmarken, één factureringsoppervlak wil behouden of fallback-routes wil onderhouden zonder de applicatie opnieuw op te bouwen rond elke vendorspecifieke SDK.

• OpenAI-compatibele integratie: bestaande OpenAI SDK-clients kunnen worden hergebruikt door de basis-URL, API-sleutel en model-ID te wijzigen.
• Eén sleutel voor meerdere modelproviders, waardoor A/B-tests en fallback-routing eenvoudiger te implementeren zijn.
• Gecentraliseerd gebruiks- en modelniveau-kostenbeheer in plaats van afzonderlijke providerdashboards.
• Snelle modelwissel wanneer een workload een andere balans van kwaliteit, latency, modaliteits-ondersteuning of prijs nodig heeft.

De live MiniMax M3 CometAPI-pagina vermeldt momenteel model-ID minimax-m3, POST /v1/chat/completions, en OpenAI SDK-voorbeelden.

MiniMax M3 API gebruiken met CometAPI

Stap 1: Maak een CometAPI-account en verkrijg een API-sleutel

Maak een account aan of log in op uw CometAPI-account, genereer vervolgens een API-token via de tokenconsole. Sla het token op in een omgevingsvariabele in plaats van het in de broncode op te nemen.

export COMETAPI_KEY="your-key-here"

Stap 2: Configureer de OpenAI-client

De OpenAI-compatibele basis-URL van CometAPI is:

https://api.cometapi.com/v1

Installeer de OpenAI SDK en wijs de client naar CometAPI:

pip install openai

   from openai import OpenAI
   import os

   client = OpenAI(
      api_key=os.environ["COMETAPI_KEY"],
      base_url="https://api.cometapi.com/v1",
   )

Stap 3: Doe uw eerste MiniMax M3-aanvraag

Gebruik de CometAPI model-ID minimax-m3. Een minimale cURL-aanvraag ziet er zo uit:

curl   https://api.cometapi.com/v1/chat/completions \
  -H "Authorization: Bearer   $COMETAPI_KEY" \
  -H "Content-Type:   application/json" \
  -d '{
    "model":   "minimax-m3",
    "messages": [
      {
        "role":   "system",
        "content": "You   are a precise software engineering assistant."
      },
      {
        "role":   "user",
        "content":   "Review this migration plan and list three high-risk failure   modes."
      }
    ],
    "max_completion_tokens":   1200,
    "reasoning_split": true
  }' 

Python:

completion = client.chat.completions.create(
    model="minimax-m3",
    messages=[
        {"role":   "system", "content": "You are a precise technical   assistant."},
        {"role":   "user", "content": "Explain how sparse attention   helps long-context coding agents."},
    ],
    max_completion_tokens=1200,
      extra_body={"reasoning_split": True},
   )

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

De live M3-pagina van CometAPI gebruikt hetzelfde reasoning_split patroon in het Python-voorbeeld. Deze schakelaar wijzigt hoe redeneringsinhoud wordt geretourneerd; hij schakelt denken zelf niet aan of uit.

Stap 4: Streaming inschakelen

Streaming is nuttig voor chatinterfaces, codeerassistenten en lange completions omdat gebruikers output kunnen zien terwijl die binnenkomt. MiniMax’s OpenAI-compatibele documentatie bevestigt streamingondersteuning voor M3.

stream = client.chat.completions.create(
    model="minimax-m3",
    messages=[{"role":   "user", "content": "Create a phased plan for   migrating a monolith to services."}],
    stream=True,
    max_completion_tokens=3000,
   )

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

Stap 5: Redeneren inschakelen of uitschakelen

MiniMax definieert adaptieve en uitgeschakelde denkmodi voor M3. Gebruik adaptief denken voor moeilijke codering, planning en agenttaken; schakel het uit voor eenvoudige extractie, classificatie of latency-gevoelige responses. Bij het gebruik van providerspecifieke velden via een OpenAI-compatibele router, valideer ze in de CometAPI-playground vóór productie, omdat pass-through gedrag kan evolueren.

# Deeper reasoning
   completion = client.chat.completions.create(
    model="minimax-m3",
    messages=[{"role":   "user", "content": "Find the root cause of this   distributed transaction failure."}],
    extra_body={"thinking":   {"type": "adaptive"}},
   )

   # Faster direct answer
   completion = client.chat.completions.create(
    model="minimax-m3",
    messages=[{"role":   "user", "content": "Extract the invoice number from   this text."}],
    extra_body={"thinking":   {"type": "disabled"}},
   )

Stap 6: Afbeeldingsinvoer gebruiken

De OpenAI-compatibele API van M3 accepteert image_url contentdelen. Hetzelfde typed-content patroon is de natuurlijke manier om screenshots, diagrammen of grafieken via een OpenAI-stijl route te sturen.

response = client.chat.completions.create(
    model="minimax-m3",
    messages=[{
        "role":   "user",
        "content": [
            {"type":   "text", "text": "Review this dashboard screenshot   and identify the likely UI problems."},
            {
                "type":   "image_url",
                "image_url":   {
                    "url":   "https://example.com/dashboard.png",
                    "detail":   "default"
                }
            }
        ]
    }]
   )

MiniMax documenteert ondersteuning voor JPEG, PNG, GIF en WEBP, met afbeeldingsdetailniveaus laag, default of hoog. De provider publiceert ook limieten voor requestgrootte, dus controleer de laatste multimodale API-limieten voordat u grote assets verzendt.

Stap 7: Videoinvoer gebruiken

M3 ondersteunt ook video_url contentdelen. MiniMax documenteert MP4, AVI, MOV en MKV, en ondersteunt grotere video’s via zijn Files API.

response = client.chat.completions.create(
    model="minimax-m3",
    messages=[{
        "role":   "user",
        "content": [
            {"type":   "text", "text": "Summarize the workflow in this   product demo and list every visible error state."},
            {
                "type":   "video_url",
                "video_url":   {"url": "mm_file://your_file_id", "detail":   "default"}
            }
        ]
    }]
   )

Als uw applicatie multimodale verzoeken via CometAPI routeert, bevestig dan het exacte bestandstransport dat door de actieve M3-route wordt ondersteund; de providerspecifieke mm_file://-identifier hoort bij MiniMax’s Files-workflow.

Stap 8: Functie- en toolaanroepen toevoegen

MiniMax M3 ondersteunt tooldefinities in de OpenAI-compatibele API. Een productieagent moet de gevraagde tool uitvoeren, het volledige assistant tool-call bericht aan de conversatiegeschiedenis toevoegen en vervolgens het toolresultaat teruggeven aan het model. MiniMax waarschuwt expliciet dat het behouden van het volledige antwoord belangrijk is voor de continuïteit van redeneren.

tools = [{
    "type":   "function",
    "function": {
        "name":   "get_build_status",
        "description":   "Get the current CI build status for a repository.",
        "parameters": {
            "type":   "object",
            "properties": {
                "repo":   {"type": "string"},
                "branch":   {"type": "string"}
            },
            "required":   ["repo", "branch"]
        }
    }
   }]

   response = client.chat.completions.create(
    model="minimax-m3",
    messages=[{"role":   "user", "content": "Check whether the main branch of   acme/payments is passing CI."}],
    tools=tools,
   )

Stap 9: Gebruik lange context en promptcaching verstandig

Een contextvenster van 1M tokens betekent niet dat elke aanvraag 1M tokens moet bevatten. Voeg alleen de bestanden, logs, documenten en tooloutputs toe die relevant zijn voor de taak. MiniMax’s automatische promptcaching kan kosten en verwerkingstijd verminderen wanneer herhaalde prefixes zoals system-prompts, toollijsten of conversatiegeschiedenis terugkeren in aanvragen.

Voor agents op repository-schaal is een goed patroon om een stabiele projectsamenvatting en toolschema te behouden, alleen de bestanden op te halen die relevant zijn voor de huidige stap en periodiek verouderde geschiedenis te comprimeren in plaats van de sessie onbeperkt te laten groeien.

Belangrijke parameters voor de MiniMax M3 API

De parameterdefinities hierboven volgen MiniMax’s huidige OpenAI-compatibele API-referentie. Sommige providerspecifieke velden vereisen mogelijk pass-through ondersteuning wanneer ze via een aggregator worden gerouteerd, dus test niet-standaard velden tegen het huidige CometAPI-endpoint vóór uitrol.

MiniMax officiële API versus CometAPI

MiniMax ondersteunt officieel zowel Anthropic-compatibele als OpenAI-compatibele aanroepen. De directe Anthropic-route wordt door MiniMax aanbevolen voor geavanceerd denkgedrag; de M3-modelpagina van CometAPI benadrukt momenteel de OpenAI-stijl /v1/chat/completions integratie.

Prijzen van de MiniMax M3 API

Prijzen verdienen zorgvuldige behandeling omdat het effectieve directe MiniMax-tarief en het lijsttarief dat op de CometAPI-vergelijking wordt getoond momenteel niet hetzelfde zijn. Per 10 augustus 2026 toont CometAPI M3 op $0,48/M invoer en $1,92/M uitvoer. Dezelfde CometAPI-pagina vergelijkt die tarieven met een MiniMax-lijstprijs van $0,60/M invoer en $2,40/M uitvoer.

MiniMax’s huidige pay-as-you-go prijspagina toont echter een permanente 50% korting op standaard M3-verkeer: voor aanvragen met niet meer dan 512K invoertokens is de effectieve directe prijs $0,30/M invoer, $1,20/M uitvoer en $0,06/M cache-read. Boven 512K invoer zijn de afgeprijsde directe tarieven $0,60/M invoer, $2,40/M uitvoer en $0,12/M cache-read.

Dit betekent dat CometAPI momenteel onder MiniMax’s nominale lijstprijs zit, maar niet onder het afgeprijsde directe <=512K tarief van de provider. Voor deployments met hoog volume: vergelijk live prijzen in plaats van te vertrouwen op een vaste “20% goedkoper”-claim. Prijzen kunnen onafhankelijk op elk platform veranderen.

Voorbeeldkosten

Bij het huidige M3-tarief van CometAPI zou een aanvraag met 100.000 invoertokens en 5.000 uitvoertokens ongeveer kosten:

Dezelfde aanvraag kan minder kosten op MiniMax direct als deze in aanmerking komt voor de huidige afgeprijsde <=512K-laag van de provider, maar teams met meerdere modellen kunnen nog steeds waarde hechten aan de operationele eenvoud van een geünificeerde gateway.

MiniMax M3 versus Claude Sonnet 5 versus Gemini 3.6 Flash versus Kimi K3

Alle vier de modellen richten zich op agent- en coderingsworkloads, en ze bieden allemaal zeer grote contextvensters. Hun verschillen zijn zichtbaarder in modaliteitsondersteuning, redeneringscontrols, providerecosystemen en huidige CometAPI-prijzen. Officiële providerdocumentatie bevestigt een 1M contextvenster voor Claude Sonnet 5, een multimodale API met grote context voor Gemini 3.6 Flash, en een 1M-token vlaggenschip Kimi K3.

Huidige CometAPI-tokenprijzen in de tabel zijn afkomstig van de live modelpagina’s voor MiniMax M3, Claude Sonnet 5, Gemini 3.6 Flash, en Kimi K3.

Figuur 4. Huidige CometAPI token-prijsvergelijking, gecontroleerd op 10 augustus 2026. Model-pagina bronnen: M3, Gemini 3.6 Flash, Claude Sonnet 5, en Kimi K3.

Welk model moet u kiezen?

• MiniMax M3 als uw prioriteit lage CometAPI-tokenprijzen, 1M context, native beeld-/videobegrip en langlopende codering- of tool-use agents zijn.
• Claude Sonnet 5 wanneer u gepolijste coderingagents, professioneel kenniswerk en volwassen Anthropic-stijl toolworkflows prioriteert.
• Gemini 3.6 Flash wanneer multimodaliteit, snelle agentloops, Google-native tools, audio/PDF-invoer en throughput het belangrijkst zijn.
• Kimi K3 wanneer de workload draait om langetermijn codering, diep kenniswerk en een altijd-redenerend model met een 1M contextvenster.

Selecteer niet puur op basis van één benchmark of tokenprijs. Bouw een kleine evaluatieset op uit uw eigen repository, documenten, toolaanroepen en failure-cases, en vergelijk vervolgens succesratio per taak, latency, totale tokens, retries en tijd voor menselijke correctie.

Best practices voor de MiniMax M3 API

• Stel denken expliciet in. Gebruik adaptief voor echt moeilijk werk en disabled voor eenvoudige taken waar latency telt. Expliciete instellingen zijn gemakkelijker te benchmarken en te reproduceren.
• Gebruik het 1M-venster selectief. Een groot contextvenster is een capaciteitsplafond, geen doel. Haal op en comprimeer voordat u grote repositories of documentcollecties verstuurt.
• Behoud tool-call geschiedenis. Voor multi-turn functieaanroepen, houd het volledige assistant-antwoord en tool-call objecten bij zodat de continuïteit van redeneren niet wordt doorbroken.
• Stream lange antwoorden. Streaming verbetert de waargenomen latency voor codering, onderzoek en agentapplicaties, zelfs wanneer de totale voltooiingstijd onveranderd is.
• Benut caching van herhaalde context. Stabiele system-prompts, toolschema’s en herhaalde geschiedenis zijn goede kandidaten voor promptcaching wanneer de actieve route dit ondersteunt.
• Meet kosten per succesvolle taak. Tokenprijs is belangrijk, maar retries, toolloops, lange redeneringstrajecten en herstel na fouten domineren vaak de uiteindelijke economie van een agent.
• Test providerspecifieke parameters opnieuw. OpenAI-compatibele gateways kunnen verschillen in hoe ze niet-standaard velden doorgeven. Valideer thinking, reasoning_split, multimodale payloads en toolgedrag vóór productie.

Conclusie

MiniMax M3 is een sterke API-optie voor ontwikkelaars die codering, agent-executie, native visueel begrip en een zeer lang contextvenster in één model nodig hebben. Het technische verhaal is ongewoon coherent: MSA pakt de servinguitdaging van 1M context aan, native multimodale training verbreedt het invoeroppervlak, en de publieke benchmarkset is gericht op de software-engineering en tool-use workloads waar ontwikkelaars daadwerkelijk om geven.

Voor de meeste CometAPI-gebruikers is het snelste startpunt eenvoudig: maak een sleutel aan, stel de basis-URL in op https://api.cometapi.com/v1, roep model minimax-m3 aan en benchmark het tegen uw echte productietaken. Beslis vervolgens of u dieper denken wilt inschakelen, multimodale invoer wilt toevoegen of een toollaag wilt bouwen. Omdat prijzen en routegedrag kunnen veranderen, controleer vóór definitieve productie-uitrol opnieuw de live CometAPI M3-pagina en MiniMax API-documentatie.