Sådan bruger du MiniMax M3 API

TLDR MiniMax M3 kombinerer et kontekstvindue på 1,000,000 tokens, indbygget forståelse af tekst-billede-video, stærk kodnings- og agent-ydelse samt MiniMax Sparse Attention (MSA). Udviklere kan kalde MiniMax M3 via CometAPI’s OpenAI-kompatible gateway på https://api.cometapi.com/v1 med model-ID minimax-m3.

Denne vejledning dækker modellens specifikationer, officielle benchmarkdata, API-opsætning, streaming, styring af ræsonnering, multimodale forespørgsler, tool calling, priser og sammenligninger med andre frontier-API’er i 2026.

Vigtigste pointer

• MiniMax M3 understøtter op til 1M tokens kontekst, hvilket muliggør kodning i repository-skala og langvarige agentsessioner.
• Modellen er indfødt multimodal fra træningens første skridt og accepterer tekst-, billed- og video-input.
• Dens MiniMax Sparse Attention-arkitektur er designet til at gøre million-token-kontekst mere beregningsmæssigt praktisk. Officielle resultater inkluderer 59,0% på SWE-Bench Pro og 66,0% på Terminal-Bench 2.1 samt stærke agent- og værktøjsbrugs-score.
• MiniMax’s OpenAI-kompatible API understøtter adaptiv eller deaktiveret tænkning, streaming, tools og reasoning_split.
• På CometAPI er det aktuelle model-ID minimax-m3 og hoved-endpointet er /v1/chat/completions.

Hvad er MiniMax M3?

MiniMax M3 er designet omkring tre arbejdsbelastninger, der i stigende grad definerer frontier-udviklermodeller: software engineering i stor skala, autonom agenteksekvering og multimodal langtidskontekst-ræsonnering. MiniMax beskriver M3 som en model, der når frontier-niveau på kodnings- og agentopgaver, samtidig med at den kombinerer 1M kontekst, indfødt multimodalitet og MSA. Det praktiske resultat er en model, der er mindre rettet mod isolerede chat-ture og mere mod arbejdsgange, der akkumulerer filer, værktøjsresultater, skærmbilleder, kodeændringer og ræsonneringstilstand over tid.

M3 er tilgængelig via MiniMax’s eget API-økosystem og via CometAPI’s MiniMax M3-endpoint. For udviklere, der allerede bruger OpenAI SDK, bevarer CometAPI-ruten den velkendte Chat Completions-form og gør det lettere at sammenligne M3 med modeller fra Anthropic, Google, Moonshot AI og andre udbydere.

MiniMax M3 tekniske specifikationer

Kontekst- og modalitetstallene ovenfor er bekræftet i MiniMax’s API-dokumentation, mens modelarkitekturen og positioneringen kommer fra den officielle M3-udgivelse.

Hvad gør MiniMax M3 anderledes?

MiniMax Sparse Attention og 1M kontekst

Et kontekstvindue på en million tokens er kun nyttigt, hvis serving-arkitekturen kan behandle det med acceptabel hastighed og omkostning. M3 adresserer det problem med MiniMax Sparse Attention (MSA), som først identificerer relevante KV-blokke og derefter udfører sparsom attention over udvalgte regioner i stedet for at anvende fuld kvadratisk attention overalt.

MiniMax rapporterer, at ved 1M kontekstlængde bruger M3 cirka 1/20 af den forrige generations beregning pr. token, med mere end 9x hurtigere prefill og mere end 15x hurtigere decoding. Dette er leverandørrapporterede engineering-resultater snarere end tredjeparts serving-målinger, men de forklarer, hvorfor MSA er centralt for M3’s langkontekstdesign.

Figur 1. MiniMax Sparse Attention-arkitektur. Kilde: MiniMaxs officielle M3-udgivelse

Indfødt multimodalitet

MiniMax siger, at M3 gennemgik mixed-modality-træning fra første skridt, i stedet for at tilføje et separat visionlag efter tekst-fortræning. I den OpenAI-kompatible API accepterer M3 tekst-, billede- og videoindholdsdele. Billeder kan leveres med image_url og videoer med video_url; understøttede billedformater omfatter JPEG, PNG, GIF og WEBP, mens understøttede videoformater omfatter MP4, AVI, MOV og MKV.

For udviklere gør det én model anvendelig til opgaver som fejlfinding baseret på skærmbilleder, fortolkning af diagrammer, UI-review, analyse af tekniske dokumenter og videoforståelse uden at skulle sende hvert visuelt input gennem en separat model.

Kodning og agent-arbejdsgange

M3’s stærkeste offentlige positionering er ikke generisk chat. MiniMax fokuserer på fejlrettelser, frontend- og backend-udvikling, terminaleksekvering, performanceoptimering, værktøjskald og samarbejde over lang horisont. Det officielle M3-benchmark-sæt lægger derfor vægt på software engineering- og agent-benchmarks frem for kun akademiske QA-tests.

Konfigurerbar tænkning

I MiniMax’s OpenAI-kompatible API understøtter M3 eksplicit styring af ræsonnering: tænkning kan sættes til adaptive eller disabled. Hvis feltet udelades på MiniMax’s OpenAI-kompatible endpoint, er tænkning aktiveret som standard. For produktionsintegrationer er det sikrere at sætte feltet eksplicit, da det gør latenstid og adfærd lettere at reproducere på tværs af miljøer.

Langsigtet agentydelse

MiniMax offentliggjorde også to langvarige casestudier, der viser, hvorfor M3’s kontekstdesign betyder noget. I en paper-reproduktion opgave kørte M3 autonomt i næsten 12 timer, producerede 18 commits og 23 eksperimentelle figurer, mens den reproducerede kerneeksperimenterne i en ICLR 2025 Outstanding Paper. Opgaven krævede læsning af figurer og formler, redigering af kode, sporing af eksperimenter og fastholdelse af en lang eksekveringshistorik.

I en separat CUDA-kerneloptimeringsøvelse rapporterer MiniMax 147 benchmark-indsendelser og 1.959 værktøjskald over cirka 24 timer, med Hopper FP8 hardware-peak-udnyttelse stigende fra 7,6% til 71,3%, svarende til en rapporteret 9,4x hastighedsforøgelse. Disse eksempler er kontrollerede demonstrationer snarere end garantier for enhver produktionsagent, men de illustrerer den tiltænkte brugssag: vedholdende værktøjsloops hvor fremskridt kan komme først efter mange iterationer.

Hvorfor bruge MiniMax M3 API via CometAPI?

CometAPI eksponerer M3 gennem det samme generelle API-miljø, der bruges til hundredvis af andre modeller. Det betyder noget, når et team vil benchmarke flere udbydere, beholde én faktureringsflade eller vedligeholde fallback-ruter uden at genopbygge applikationen omkring hver leverandørspecifik SDK.

• OpenAI-kompatibel integration: eksisterende OpenAI SDK-klienter kan genbruges ved at ændre base-URL, API-nøgle og model-ID.
• Én nøgle til flere modeludbydere, hvilket gør A/B-tests og fallback-routing nemmere at implementere.
• Centraliseret forbrug og omkostningssporing på modelniveau i stedet for separate udbyderdashboards.
• Hurtigt modelswitch, når en arbejdsbelastning har brug for en anden balance mellem kvalitet, latenstid, modalitetsstøtte eller pris.

Den live MiniMax M3 CometAPI-side viser i øjeblikket model-ID minimax-m3, POST /v1/chat/completions og OpenAI SDK-eksempler.

Sådan bruger du MiniMax M3 API med CometAPI

Trin 1: Opret en CometAPI-konto og få en API-nøgle

Opret eller log ind på din CometAPI-konto, og generér derefter et API-token fra token-konsollen. Gem tokenet i en miljøvariabel i stedet for at committe det til kildekoden.

export COMETAPI_KEY="your-key-here"

Trin 2: Konfigurer OpenAI-klienten

CometAPI OpenAI-kompatibel base-URL er:

https://api.cometapi.com/v1

Installer OpenAI SDK og peg klienten mod 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",
   )

Trin 3: Lav din første MiniMax M3-forespørgsel

Brug CometAPI model-ID’et minimax-m3. En minimal cURL-forespørgsel ser sådan ud:

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)

CometAPI’s live M3-side bruger det samme reasoning_split-mønster i sit Python-eksempel. Denne switch ændrer, hvordan ræsonneringsindhold returneres; den aktiverer eller deaktiverer ikke i sig selv tænkning.

Trin 4: Aktivér streaming

Streaming er nyttig for chatgrænseflader, kodeassistenter og lange completions, fordi brugere kan se output, efterhånden som det kommer. MiniMax’s OpenAI-kompatible dokumentation bekræfter streaming-understøttelse for 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)

Trin 5: Aktivér eller deaktiver tænkning

MiniMax definerer adaptive og disabled tænkningstilstande for M3. Brug adaptive til svær kodning, planlægning og agentopgaver; deaktiver den for simpel ekstraktion, klassifikation eller latenstidsfølsomme svar. Når du bruger leverandørspecifikke felter gennem en OpenAI-kompatibel router, skal du validere dem i CometAPI playground’en før produktion, da passthrough-adfærd kan udvikle sig.

# 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"}},
   )

Trin 6: Brug billed-input

M3’s OpenAI-kompatible API accepterer image_url-indholdsdele. Det samme typed-content-mønster er den naturlige måde at sende skærmbilleder, diagrammer eller grafer gennem en OpenAI-lignende rute.

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 dokumenterer understøttelse af JPEG, PNG, GIF og WEBP med billeddetaljeniveauer low, default eller high. Udbyderen offentliggør også begrænsninger for anmodningsstørrelse, så tjek de seneste multimodale API-grænser, før du sender store aktiver.

Trin 7: Brug video-input

M3 understøtter også video_url-indholdsdele. MiniMax dokumenterer MP4, AVI, MOV og MKV og understøtter større videoer gennem sin 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"}
            }
        ]
    }]
   )

Hvis din applikation sender multimodale forespørgsler gennem CometAPI, skal du bekræfte den præcise filtransport, som den aktive M3-rute understøtter; den udbydernative mm_file://-identifikator tilhører MiniMax’s Files-arbejdsgang.

Trin 8: Tilføj function- og tool calling

MiniMax M3 understøtter værktøjsdefinitioner i den OpenAI-kompatible API. En produktionsagent bør eksekvere det anmodede værktøj, tilføje den komplette assistent tool-call-besked til samtalehistorikken og derefter returnere værktøjsresultatet til modellen. MiniMax advarer eksplicit om, at bevarelse af den komplette respons er vigtig for ræsonneringskontinuitet.

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,
   )

Trin 9: Brug lang kontekst og prompt-caching med omtanke

Et kontekstvindue på 1M tokens betyder ikke, at hver forespørgsel skal indeholde 1M tokens. Pak kun de filer, logs, dokumenter og værktøjsoutput, der er relevante for opgaven. MiniMax’s automatiske prompt-caching kan reducere omkostninger og behandlingstid, når gentagne præfikser som systemprompter, værktøjslister eller samtalehistorik går igen på tværs af forespørgsler.

For agenter i repository-skala er et godt mønster at beholde en stabil projektsammenfatning og værktøjsskema, hente kun de filer, der er relevante for det aktuelle trin, og periodisk komprimere forældet historik i stedet for at lade sessionen vokse uden grænse.

Vigtige MiniMax M3 API-parametre

Parameterdefinitionerne ovenfor følger MiniMax’s aktuelle OpenAI-kompatible API-reference. Nogle leverandørspecifikke felter kan kræve passthrough-understøttelse, når de sendes gennem en aggregator, så test ikke-standardfelter mod det aktuelle CometAPI-endpoint før udrulning.

MiniMax officiel API vs CometAPI

MiniMax understøtter officielt både Anthropic-kompatibel og OpenAI-kompatibel invocation. Den direkte Anthropic-rute anbefales af MiniMax til avanceret tænkning; CometAPI’s M3-modelside lægger i øjeblikket vægt på OpenAI-stilen /v1/chat/completions-integration.

MiniMax M3 API-priser

Priser kræver omhyggelig behandling, fordi den effektive direkte MiniMax-sats og listesatsen vist på CometAPI-sammenligningen i øjeblikket ikke er den samme. Pr. 10. august 2026 viser CometAPI M3 til $0.48/M input og $1.92/M output. Den samme CometAPI-side sammenligner disse satser med en MiniMax-listpris på $0.60/M input og $2.40/M output.

MiniMax’s aktuelle pay-as-you-go-prisside viser dog en permanent 50% rabat på standard M3-trafik: for forespørgsler med højst 512K inputtokens er den effektive direkte pris $0.30/M input, $1.20/M output og $0.06/M cache-læsning. Over 512K input er de rabatterede direkte satser $0.60/M input, $2.40/M output og $0.12/M cache-læsning.

Det betyder, at CometAPI i øjeblikket ligger under MiniMax’s nominelle listepris, men ikke under udbyderens rabatterede direkte <=512K-sats. For udrulninger med stort volumen bør du sammenligne livepriser frem for at stole på en fast “20% billigere”-påstand. Priser kan ændre sig uafhængigt på begge platforme.

Eksempelomkostning

Ved CometAPI’s aktuelle M3-sats vil en forespørgsel med 100,000 inputtokens og 5,000 outputtokens koste cirka:

Den samme forespørgsel kan koste mindre direkte hos MiniMax, hvis den kvalificerer til udbyderens aktuelle rabatterede <=512K-niveau, men teams med flere modeller kan stadig værdsætte den operationelle enkelhed ved en samlet gateway.

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

Alle fire modeller sigter mod agentbaserede og kodningsarbejdsbelastninger, og alle tilbyder meget store kontekstvinduer. Deres forskelle er mere synlige i modalitetsstøtte, styring af ræsonnering, udbyderøkosystemer og aktuelle CometAPI-priser. Officiel udbyderdokumentation bekræfter et 1M kontekstvindue for Claude Sonnet 5, en stor-kontekst multimodal API for Gemini 3.6 Flash og en 1M-token flagskib Kimi K3.

De aktuelle CometAPI-tokenpriser i tabellen er hentet fra de live modelsider for MiniMax M3, Claude Sonnet 5, Gemini 3.6 Flash og Kimi K3.

Figur 4. Aktuel sammenligning af CometAPI tokenpriser, tjekket 10. august 2026. Kilder til modelsider: M3, Gemini 3.6 Flash, Claude Sonnet 5*** og*** Kimi K3.

Hvilken model skal du vælge?

• MiniMax M3, hvis din prioritet er lav CometAPI-tokenpris, 1M kontekst, indfødt billede-/videoforståelse og langvarige kodnings- eller værktøjsbrugsagenter.
• Claude Sonnet 5, når du prioriterer polerede kodningsagenter, professionelt vidensarbejde og modne Anthropic-lignende værktøjsarbejdsgange.
• Gemini 3.6 Flash, når multimodalitet, hurtige agent-loops, Google-native værktøjer, lyd/PDF-input og throughput betyder mest.
• Kimi K3, når arbejdsbelastningen centrerer sig om langsigtet kodning, dybt vidensarbejde og en model, der altid ræsonnerer med et 1M kontekstvindue.

Vælg ikke udelukkende ud fra ét benchmark eller tokenpris. Byg et lille evalueringssæt fra dit eget repository, dine dokumenter, værktøjskald og fejlsager, og sammenlign derefter succesrate, latenstid, samlede tokens, retries og menneskelig korrektionstid.

MiniMax M3 API best practices

• Angiv tænkning eksplicit. Brug adaptive til reelt vanskeligt arbejde og disabled til simple opgaver, hvor latenstid betyder noget. Eksplicitte indstillinger er lettere at benchmarke og reproducere.
• Brug 1M-vinduet selektivt. Et stort kontekstvindue er en kapacitetsgrænse, ikke et mål. Hent og komprimer, før du sender store repositories eller dokumentindsamlinger.
• Bevar værktøjskaldshistorik. For multi-turn function calling skal du beholde den komplette assistentrespons og tool-call-objekter, så ræsonneringskontinuitet ikke brydes.
• Stream lange svar. Streaming forbedrer oplevet latenstid for kodning, research og agentapplikationer, selv når den samlede completion-tid er uændret.
• Udnyt caching af gentagen kontekst. Stabile systemprompter, værktøjsskemaer og gentaget historik er gode kandidater til prompt-caching, når den aktive rute understøtter det.
• Mål omkostning pr. vellykket opgave. Tokenpris betyder noget, men retries, værktøjsloops, lange ræsonneringsspor og fejlgendannelse dominerer ofte den endelige økonomi for en agent.
• Retest leverandørspecifikke parametre. OpenAI-kompatible gateways kan variere i, hvordan de videresender ikke-standardfelter. Validér thinking, reasoning_split, multimodale payloads og værktøjsadfærd før produktion.

Konklusion

MiniMax M3 er en stærk API-mulighed for udviklere, der har brug for kodning, agenteksekvering, indfødt visuel forståelse og meget lang kontekst i én model. Dens tekniske historie er usædvanligt sammenhængende: MSA adresserer serving-udfordringen ved 1M kontekst, indfødt multimodal træning udvider inputfladen, og det offentlige benchmark-sæt fokuserer på de software engineering- og værktøjsbrugs-arbejdsbelastninger, udviklere faktisk går op i.

For de fleste CometAPI-brugere er den hurtigste start lige ud ad landevejen: opret en nøgle, sæt base-URL’en til https://api.cometapi.com/v1, kald modellen minimax-m3, og benchmark den mod dine reelle produktionsopgaver. Beslut derefter, om du vil aktivere dybere tænkning, tilføje multimodalt input eller bygge et værktøjsloop. Fordi priser og ruteadfærd kan ændre sig, skal du tjekke den live CometAPI M3-side og MiniMax API-dokumentationen igen før endelig produktionsudrulning.