DEV Community

Cover image for Como Usar a API MiniMax M3? Guia Completo
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Usar a API MiniMax M3? Guia Completo

MiniMax M3 é um modelo de raciocínio e codificação com janela de contexto de até 1.000.000 de tokens. Na prática, isso permite enviar um repositório grande, logs extensos ou um documento de design longo e pedir ao modelo para analisar tudo em uma única chamada. Se você quiser entender o posicionamento do modelo antes de implementar, leia o que é MiniMax M3.

Experimente o Apidog hoje

Este guia foca na implementação: você vai gerar uma chave de API, enviar chamadas com curl, Python e Node.js, testar o endpoint no Apidog e validar a resposta bruta antes de colocar a integração no seu código. Se quiser acompanhar visualmente, baixe o Apidog.

A referência oficial está nos docs da API MiniMax. Mantenha essa aba aberta para confirmar campos, limites e formatos atualizados.

MiniMax M3

O que você vai precisar

Antes de começar, confirme que você tem:

  • Uma conta MiniMax em platform.minimax.io.
  • Uma chave de API.
  • Uma forma de pagamento ativa: créditos pré-pagos ou plano de tokens por assinatura.

Para os exemplos com curl, nada além do terminal é necessário. Para os exemplos com SDK:

  • Python 3.8+
  • Node.js 18+

Passo 1: Gere sua chave de API

Faça login em platform.minimax.io, abra a seção de chaves de API da sua conta e crie uma nova chave.

O MiniMax emite dois tipos de credenciais:

  • Chave de API regular: usa seu saldo pré-pago.
  • Chave de assinatura: usa os créditos de token do seu plano Plus, Max ou Ultra. Quando os tokens do plano acabam, as chamadas com essa chave param até a renovação do plano ou troca para uma chave pré-paga.

Escolha o tipo de chave conforme o modelo de cobrança que você pretende usar.

Depois de criar a chave, copie e armazene com segurança. Você não verá o valor novamente.

Nunca coloque a chave diretamente no código-fonte. Exporte-a como variável de ambiente:

export MINIMAX_API_KEY="your-key-here"
Enter fullscreen mode Exit fullscreen mode

Isso evita vazamento em commits, logs ou arquivos compartilhados. Se você trabalha com chaves dentro do editor, aplique a mesma regra. Veja também segurança de chaves de API para extensões do VS Code.

Passo 2: Envie sua primeira requisição

A URL base da API é:

https://api.minimax.io/v1
Enter fullscreen mode Exit fullscreen mode

O endpoint de chat é:

POST https://api.minimax.io/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

A autenticação usa Bearer Token:

Authorization: Bearer $MINIMAX_API_KEY
Enter fullscreen mode Exit fullscreen mode

O ID do modelo é:

MiniMax-M3
Enter fullscreen mode Exit fullscreen mode

Exemplo com curl

Use este exemplo para validar a chamada mais simples:

curl https://api.minimax.io/v1/chat/completions \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMax-M3",
    "messages": [
      {
        "role": "user",
        "content": "Refactor this function to be async."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Você pode chamar o M3 por HTTP puro, SDK da OpenAI ou SDK da Anthropic. O MiniMax recomenda o SDK da Anthropic, mas o SDK da OpenAI também funciona apontando para a base_url do MiniMax.

Exemplo com Python e SDK da OpenAI

Instale o SDK, se necessário:

pip install openai
Enter fullscreen mode Exit fullscreen mode

Código:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_API_KEY"],
)

response = client.chat.completions.create(
    model="MiniMax-M3",
    messages=[
        {
            "role": "user",
            "content": "Refactor this function to be async."
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

A diferença em relação a uma configuração padrão da OpenAI é a base_url.

Exemplo com Node.js

Instale o SDK:

npm install openai
Enter fullscreen mode Exit fullscreen mode

Código:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.minimax.io/v1",
  apiKey: process.env.MINIMAX_API_KEY,
});

const response = await client.chat.completions.create({
  model: "MiniMax-M3",
  messages: [
    {
      role: "user",
      content: "Refactor this function to be async.",
    },
  ],
});

console.log(response.choices[0].message.content);
Enter fullscreen mode Exit fullscreen mode

Se você já usou a API Qwen 3.7, o padrão é semelhante: muitos modelos expõem uma interface compatível com OpenAI, então a migração costuma exigir apenas a troca da URL base e do modelo.

Para opções completas de cliente, consulte os docs do SDK Python da OpenAI e os docs do SDK da Anthropic.

Passo 3: Teste e inspecione no Apidog

Antes de colocar a chamada dentro da aplicação, teste manualmente a requisição e veja a resposta bruta. Isso ajuda a validar autenticação, payload, formato de resposta e mensagens de erro.

Abra o Apidog e configure a requisição.

Requisição MiniMax M3 no Apidog

Siga estes passos:

  1. Crie uma nova requisição HTTP.
  2. Defina o método como POST.
  3. Use a URL: 
   https://api.minimax.io/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode
  1. Abra o painel de ambientes.
  2. Crie uma variável chamada MINIMAX_API_KEY.
  3. Defina o valor da variável como sua chave de API.
  4. Nos headers, adicione: 
   Authorization: Bearer {{MINIMAX_API_KEY}}
Enter fullscreen mode Exit fullscreen mode
  1. Adicione também: 
   Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode
  1. Defina o body como JSON bruto.
  2. Cole o payload: 
{
  "model": "MiniMax-M3",
  "messages": [
    {
      "role": "user",
      "content": "Refactor this function to be async."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode
  1. Clique em Enviar.
  2. Verifique o status HTTP, o corpo da resposta e possíveis erros.

[Captura de tela: a requisição e resposta do MiniMax-M3 no Apidog]

Guardar o token como variável de ambiente permite compartilhar a requisição com colegas sem expor o segredo. Também facilita trocar entre chave pré-paga e chave de assinatura alterando apenas uma variável.

Se você ativar streaming depois, o Apidog permite inspecionar os eventos enviados pelo servidor conforme chegam. Isso é útil para confirmar o formato antes de escrever o parser no seu runtime.

Passo 4: Ative ou desative o raciocínio

O M3 é um modelo de raciocínio. Por padrão, ele retorna a resposta final. Você também pode pedir para a API separar o raciocínio intermediário da resposta final usando reasoning_split.

Isso é útil para:

  • Depurar respostas complexas.
  • Auditar decisões do modelo.
  • Criar uma etapa de revisão antes de exibir o resultado.
  • Entender como o modelo abordou uma refatoração ou bug.

Com o SDK da OpenAI, passe reasoning_split via extra_body:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_API_KEY"],
)

response = client.chat.completions.create(
    model="MiniMax-M3",
    messages=[
        {
            "role": "user",
            "content": "Refactor this function to be async."
        }
    ],
    extra_body={
        "reasoning_split": True
    },
)

print(response.choices[0].message.reasoning_details[0]["text"])  # raciocínio
print(response.choices[0].message.content)                       # resposta final
Enter fullscreen mode Exit fullscreen mode

Quando reasoning_split está ativo:

  • O raciocínio vem em: 
response.choices[0].message.reasoning_details[0]["text"]
Enter fullscreen mode Exit fullscreen mode
  • A resposta final continua em: 
response.choices[0].message.content
Enter fullscreen mode Exit fullscreen mode

Na sua aplicação, mantenha os dois separados. Em geral:

  • Mostre a resposta final ao usuário.
  • Use o raciocínio para logs, debug ou verificação interna.

Ative o raciocínio para tarefas difíceis, como:

  • Refatorações em múltiplas etapas.
  • Análise de bugs.
  • Revisão de arquitetura.
  • Diagnóstico de logs.

Desative em chamadas simples e sensíveis à latência, porque tokens extras de raciocínio aumentam tempo e custo.

Passo 5: Use a janela de contexto de 1M tokens com controle

A janela de contexto grande é o principal diferencial do M3. Você pode enviar um arquivo extenso e fazer uma pergunta sobre o conteúdo inteiro.

Exemplo com logs:

with open("production-2026-05-30.log") as f:
    log_text = f.read()

response = client.chat.completions.create(
    model="MiniMax-M3",
    messages=[
        {
            "role": "user",
            "content": (
                "Find the root cause of the 502 spike at 14:20 UTC.\n\n"
                f"{log_text}"
            ),
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Mas não envie 1 milhão de tokens por padrão.

Existe um detalhe importante de cobrança: o MiniMax cobra uma taxa padrão para chamadas com até 512K tokens de entrada. Acima de 512K tokens de entrada, aplica-se uma taxa maior de contexto longo.

Ou seja, aumentar um prompt de 400K para 600K tokens não é apenas um crescimento linear. Você cruza um limite de preço.

Na prática:

  • Envie apenas os arquivos ou trechos necessários.
  • Remova logs irrelevantes.
  • Corte contexto duplicado.
  • Em agentes, reduza o histórico enviado a cada chamada.
  • Evite anexar repositórios inteiros quando uma pasta específica basta.

Para estratégias de redução de custo, veja como reduzir custos de tokens de agente.

Passo 6: Use chamada de ferramentas e entrada multimodal

O M3 suporta chamada de ferramentas e entrada multimodal. Isso permite criar fluxos em que o modelo:

  • Decide chamar uma função.
  • Recebe o resultado da função.
  • Continua o raciocínio com base nesse resultado.
  • Analisa texto e imagens, dependendo do formato suportado pela API.

Exemplo de chamada de ferramenta

Você declara as ferramentas disponíveis no payload. O modelo decide se deve chamar alguma delas.

tools = [
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite for a given module path.",
            "parameters": {
                "type": "object",
                "properties": {
                    "module": {
                        "type": "string"
                    },
                },
                "required": ["module"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="MiniMax-M3",
    messages=[
        {
            "role": "user",
            "content": "Fix the failing test in auth/session.py and confirm it passes."
        }
    ],
    tools=tools,
)
Enter fullscreen mode Exit fullscreen mode

Quando o modelo decide chamar uma ferramenta, a resposta contém um array tool_calls.

O fluxo típico é:

  1. Enviar a mensagem do usuário com a lista de ferramentas disponíveis.
  2. Ler tool_calls na resposta.
  3. Executar a função correspondente no seu código.
  4. Anexar o resultado como mensagem com role tool.
  5. Chamar a API novamente.
  6. Deixar o modelo continuar com base no resultado da ferramenta.

Essa troca de mensagens é uma das partes mais propensas a bugs em agentes. Antes de implementar em produção, leia sobre conexão de ferramentas em fluxos de trabalho de agente.

O Apidog também ajuda nesse fluxo. Você pode salvar cada etapa como uma requisição separada:

  • Requisição inicial.
  • Resposta com chamada de ferramenta.
  • Resultado simulado da ferramenta.
  • Requisição de continuação.
  • Resposta final.

Assim você valida o contrato da API antes de depurar dentro do runtime do agente.

Entrada multimodal

Para entrada multimodal, envie o conteúdo da imagem no mesmo array de mensagens, junto com o prompt de texto, usando o formato padrão de partes de conteúdo.

Como os nomes exatos dos campos podem evoluir, confirme o formato atual na referência da API.

Preços e níveis

O custo e a velocidade do serviço dependem de fatores diferentes.

Planos de token

Os planos de token definem seu orçamento de crédito. Os níveis de assinatura são:

  • Plus: US$ 20
  • Max: US$ 50
  • Ultra: US$ 120

Cada plano inclui um pool maior de créditos de token usado pela sua Chave de Assinatura.

O modelo pay-as-you-go usa uma chave de API regular e debita do seu saldo pré-pago.

Preços MiniMax M3

Níveis de serviço

Os níveis de serviço controlam a prioridade de agendamento:

  • standard: padrão, suficiente para a maioria dos workloads.
  • priority: indicado para tráfego sensível à latência ou vinculado a SLA.

Combine isso com o limite de 512K tokens do Passo 5. Seu custo real depende de:

  • Tamanho da entrada.
  • Tipo de chave.
  • Plano.
  • Nível de serviço.
  • Uso ou não de contexto longo.

Para valores atualizados por token, consulte a página de preços e modelo do MiniMax e os docs da API.

Perguntas frequentes

Existe uma forma gratuita de testar o M3?

Sim. Você pode testar o modelo sem se comprometer com um plano. Veja as opções em como usar o MiniMax M3 gratuitamente.

Quais SDKs funcionam com a API?

Você pode usar:

  • HTTP puro.
  • SDK da Anthropic.
  • SDK da OpenAI.

O MiniMax recomenda o SDK da Anthropic, mas os três acessam o mesmo endpoint:

https://api.minimax.io/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Com os clientes OpenAI e Anthropic, a principal mudança é apontar a base_url para o MiniMax.

Como faço streaming de respostas?

Adicione stream: true ao corpo da requisição:

{
  "model": "MiniMax-M3",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Explain this error log."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

A API retorna eventos enviados pelo servidor. Os SDKs expõem iteradores para ler os chunks conforme chegam.

Teste o streaming no Apidog primeiro para visualizar o formato dos eventos antes de implementar o parser.

Qual é o limite de taxa?

Os limites dependem do nível da sua conta e do serviço usado: standard ou priority.

Se receber um erro 429, implemente retry com espera incremental ou mova tráfego sensível à latência para o nível de prioridade. Verifique os números atuais no painel da conta e nos docs da API.

Como o limite de 512K afeta minha conta?

Chamadas com até 512K tokens de entrada usam a taxa padrão. Acima de 512K tokens de entrada, aplica-se a taxa maior de contexto longo.

Em loops de agentes, isso importa muito: cada chamada acumula custo. Reduza o prompt para o mínimo necessário.

Posso auto-hospedar os pesos em vez de chamar a API?

Este guia cobre a API hospedada, que é o caminho mais rápido para começar. A possibilidade de auto-hospedagem depende do que o MiniMax disponibiliza para o M3 em cada momento. Consulte a página do modelo para informações atuais sobre pesos e licenças.

Conclusão

Agora você tem o fluxo básico para usar o MiniMax M3:

  • Gerou uma chave de API.
  • Armazenou a chave como variável de ambiente.
  • Chamou o endpoint com curl.
  • Implementou exemplos em Python e Node.js.
  • Testou a requisição no Apidog.
  • Entendeu como ativar reasoning_split.
  • Viu o impacto do limite de 512K tokens.
  • Conheceu o fluxo de chamada de ferramentas.

O próximo passo é executar uma chamada real manualmente: configure o endpoint no Apidog, salve o Bearer Token como variável de ambiente, envie o prompt de refatoração e inspecione a resposta bruta. Depois disso, integrar o M3 ao seu código deve ser apenas uma questão de adaptar o payload ao seu caso de uso.

Top comments (0)