DEV Community

Cover image for Como Usar a API Grok 4.3?
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Usar a API Grok 4.3?

A xAI lançou o Grok 4.3 em fases: beta em 17 de abril de 2026, acesso à API em 30 de abril e disponibilidade geral em 6 de maio. A proposta é uma janela de contexto de 1.000.000 de tokens, entrada de vídeo nativa, raciocínio sempre ativo e redução de preço de aproximadamente 40% em relação ao Grok 4.20. Oito modelos Grok legados serão desativados em 15 de maio, então quem usa as séries grok-3 ou grok-4 deve planejar a migração imediatamente.

Experimente o Apidog hoje

Este guia mostra como chamar o Grok 4.3 a partir do seu código: endpoint, autenticação, URL base compatível com OpenAI, reasoning_effort, entrada de vídeo, chamada de funções e uma configuração de teste funcional no Apidog.

Para o lado de voz do mesmo lançamento, consulte Como usar o Grok Voice gratuitamente. Para a comparação direta contra o modelo de voz principal da OpenAI, consulte Grok Voice vs GPT-Realtime.

TL;DR

  • O Grok 4.3 ficou disponível globalmente em 6 de maio de 2026.
  • Oito modelos legados serão desativados em 15 de maio de 2026.
  • Preços: US$1,25 por 1M de tokens de entrada, US$2,50 por 1M de tokens de saída e entrada em cache por US$0,20 por 1M.
  • Janela de contexto: 1M de tokens.
  • Suporta entrada de vídeo nativa.
  • O raciocínio está sempre ativo.
  • reasoning_effort: low, medium ou high. O padrão é medium.
  • Endpoint: https://api.x.ai/v1/chat/completions.
  • URL base compatível com OpenAI: https://api.x.ai/v1.
  • Vazão informada: aproximadamente 159 tokens/segundo.
  • Índice de Inteligência 53, segundo a Análise Artificial, classificado em 10º lugar entre 146 modelos.
  • Use o Apidog para salvar requisições, alternar níveis de raciocínio e comparar respostas.

O que mudou no Grok 4.3

As mudanças mais relevantes para implementação são:

  1. Preço menor

A entrada caiu 37,5% em relação ao Grok 4.20; a saída caiu 58,3%. A entrada em cache agora custa US$0,20 por 1M de tokens, o que ajuda quando você reutiliza prompts de sistema longos.

  1. Contexto de 1M de tokens

O limite subiu de 256k no Grok 4.20 para 1M. Isso permite enviar bases de código médias, contratos extensos, transcrições longas ou históricos de conversa grandes em uma única chamada.

  1. Entrada de vídeo nativa

Pela primeira vez na linha Grok, você pode passar uma URL de vídeo e pedir ao modelo para raciocinar sobre os frames.

  1. Raciocínio sempre ativo

Toda requisição passa por uma etapa de raciocínio. O parâmetro reasoning_effort controla a profundidade, mas o modelo nunca opera abaixo de low.

  1. Melhora em fluxos agênticos

A xAI informa ganho de +300 pontos Elo no GDPval-AA em comparação com o Grok 4.20. Na prática, isso importa para chamadas de ferramentas, planejamento em múltiplas etapas e recuperação de erros.

O Índice de Inteligência de 53, segundo a Análise Artificial, coloca o Grok 4.3 acima da média de 35 para sua faixa de preço e em décimo lugar entre 146 modelos monitorados.

Pré-requisitos

Antes da primeira chamada, prepare:

  • Uma conta no xAI Console em console.x.ai.
  • Uma chave de API com faturamento habilitado.
  • O SDK da OpenAI ou o SDK da xAI.
  • Um cliente de API para salvar, reproduzir e comparar requisições.

xAI Console

Exporte sua chave de API:

export XAI_API_KEY="xai-..."
Enter fullscreen mode Exit fullscreen mode

Se estiver usando Windows PowerShell:

$env:XAI_API_KEY="xai-..."
Enter fullscreen mode Exit fullscreen mode

Endpoint e autenticação

O Grok 4.3 usa a superfície de Chat Completions compatível com OpenAI.

POST https://api.x.ai/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Cabeçalhos:

Authorization: Bearer $XAI_API_KEY
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

A compatibilidade com OpenAI permite reaproveitar boa parte do código existente. Na maioria dos casos, você muda apenas:

  • base_url
  • model
  • variáveis de ambiente

Exemplo em Python:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["XAI_API_KEY"],
    base_url="https://api.x.ai/v1",
)

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Resuma os prós e contras de GraphQL vs REST em três tópicos."
        }
    ],
    reasoning_effort="medium",
)

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

Exemplo equivalente com curl:

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "messages": [
      {
        "role": "user",
        "content": "Resuma os prós e contras de GraphQL vs REST em três tópicos."
      }
    ],
    "reasoning_effort": "medium"
  }'
Enter fullscreen mode Exit fullscreen mode

Parâmetros da requisição

Parâmetro Tipo Valores Observações
model string grok-4.3 Obrigatório.
messages array Formato OpenAI Obrigatório. Suporta system, user e assistant.
reasoning_effort string low, medium, high Opcional. Padrão: medium.
max_tokens int 1–32768 Limita a saída.
temperature float 0.0–2.0 Padrão: 1.0.
top_p float 0.0–1.0 Amostragem de núcleo.
stream bool true, false Ativa streaming via eventos enviados pelo servidor.
tools array Formato OpenAI Chamada de função.
tool_choice string ou object auto, none ou ferramenta específica Semântica padrão OpenAI.
response_format object { "type": "json_object" } Saída estruturada.
seed int qualquer inteiro Útil para reprodutibilidade com temperature: 0.

Exemplo com prompt de sistema e esforço alto:

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "messages": [
      {
        "role": "system",
        "content": "Você é um engenheiro de backend sênior."
      },
      {
        "role": "user",
        "content": "Analise este plano de consulta e aponte o gargalo."
      }
    ],
    "reasoning_effort": "high"
  }'
Enter fullscreen mode Exit fullscreen mode

A resposta segue o formato padrão:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 123,
    "completion_tokens": 456,
    "reasoning_tokens": 78,
    "total_tokens": 657
  }
}
Enter fullscreen mode Exit fullscreen mode

Como escolher reasoning_effort

Use o esforço de raciocínio como um controle de custo, latência e qualidade.

low

Use para:

  • Classificação
  • Sumarização simples
  • Extração de campos
  • Perguntas e respostas diretas
  • Normalização de texto

Exemplo:

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Classifique este ticket como bug, dúvida ou solicitação de feature: ..."
        }
    ],
    reasoning_effort="low",
)
Enter fullscreen mode Exit fullscreen mode

medium

Use para:

  • Atendimento ao cliente
  • Análise de dados simples
  • Chamada de funções
  • Tarefas com uma ou duas etapas
  • Fluxos de produção padrão

Exemplo:

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Leia este log e sugira a causa provável do erro."
        }
    ],
    reasoning_effort="medium",
)
Enter fullscreen mode Exit fullscreen mode

high

Use para:

  • Agentes de múltiplas etapas
  • Revisão de código longa
  • Planejamento
  • Matemática complexa
  • Análise de incidentes
  • Tarefas em que uma resposta errada custa caro

Exemplo:

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Revise este diff grande e identifique riscos de regressão, problemas de segurança e testes ausentes."
        }
    ],
    reasoning_effort="high",
)
Enter fullscreen mode Exit fullscreen mode

Como o raciocínio está sempre ativo, low não significa “sem raciocínio”. Ele apenas reduz a profundidade.

Chamada de funções

O Grok 4.3 usa o formato de ferramentas compatível com OpenAI.

Fluxo básico:

  1. Declare as ferramentas em tools.
  2. Envie a mensagem do usuário.
  3. Leia tool_calls na resposta do assistente.
  4. Execute a função no seu sistema.
  5. Envie o resultado de volta com role: "tool".

Exemplo:

import json
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["XAI_API_KEY"],
    base_url="https://api.x.ai/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "lookup_user",
            "description": "Procura um usuário por ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "string",
                        "description": "ID interno do usuário."
                    }
                },
                "required": ["user_id"],
            },
        },
    }
]

messages = [
    {
        "role": "user",
        "content": "Encontre o usuário u_42 e me diga o último login dele."
    }
]

response = client.chat.completions.create(
    model="grok-4.3",
    messages=messages,
    tools=tools,
    reasoning_effort="medium",
)

assistant_message = response.choices[0].message
tool_calls = assistant_message.tool_calls

print(tool_calls)
Enter fullscreen mode Exit fullscreen mode

Depois execute a ferramenta localmente:

def lookup_user(user_id: str):
    return {
        "user_id": user_id,
        "last_login": "2026-05-06T14:32:00Z"
    }

messages.append(assistant_message)

for tool_call in tool_calls:
    if tool_call.function.name == "lookup_user":
        args = json.loads(tool_call.function.arguments)
        result = lookup_user(args["user_id"])

        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result),
        })

final_response = client.chat.completions.create(
    model="grok-4.3",
    messages=messages,
    tools=tools,
    reasoning_effort="medium",
)

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

Para testar fluxos com ferramentas e repetição de chamadas, veja também teste de servidor MCP no Apidog.

Entrada de vídeo

O Grok 4.3 aceita URL de vídeo dentro de um bloco de conteúdo.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Descreva o que acontece neste clipe e aponte quaisquer anomalias."
                },
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://example.com/clip.mp4"
                    }
                },
            ],
        }
    ],
    reasoning_effort="medium",
)

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

Pontos práticos:

  • Tokens de vídeo contam como entrada.
  • Clipes longos consomem contexto rapidamente.
  • Faça corte ou downsample antes de enviar se custo e latência importarem.
  • Não é necessário extrair keyframes manualmente para o caso padrão.

Contexto de 1M de tokens

A janela de 1M de tokens permite simplificar pipelines que antes exigiam chunking agressivo.

Casos comuns:

Revisão de código

Envie:

  • Diff
  • Arquivos modificados
  • Saída do linter
  • Logs de teste
  • Regras internas de revisão

Prompt exemplo:

Revise o diff abaixo considerando:
1. bugs lógicos;
2. problemas de segurança;
3. regressões de performance;
4. testes ausentes;
5. inconsistências com o padrão do projeto.

Retorne uma lista priorizada com arquivo, linha, severidade e recomendação.
Enter fullscreen mode Exit fullscreen mode

QA de documentos longos

Envie um contrato, relatório, transcrição ou especificação completa e faça perguntas direcionadas.

Com base no documento abaixo, liste todas as obrigações com prazo inferior a 30 dias e indique a seção correspondente.
Enter fullscreen mode Exit fullscreen mode

Memória de agente

Mantenha um histórico maior da conversa para personalização, desde que o custo esteja controlado.

A entrada em cache a US$0,20 por 1M torna prompts estáveis mais baratos. Por exemplo, um prompt de sistema de 400k tokens em cache custaria US$0,08 por chamada, em vez de US$0,50 se fosse processado como entrada nova.

Migração de modelos Grok legados

Oito modelos Grok legados serão desativados em 15 de maio de 2026, 12:00 PM PT.

Se você usa grok-3, grok-4 ou variantes legadas, o primeiro passo é trocar a string do modelo:

- model="grok-4"
+ model="grok-4.3"
Enter fullscreen mode Exit fullscreen mode

Na maioria dos casos, o formato da requisição continua igual.

Checklist de migração:

  • [ ] Trocar model para grok-4.3.
  • [ ] Definir explicitamente reasoning_effort.
  • [ ] Medir latência com low, medium e high.
  • [ ] Comparar usage.reasoning_tokens.
  • [ ] Retestar parsers e regex de pós-processamento.
  • [ ] Validar chamadas de função.
  • [ ] Atualizar testes automatizados.
  • [ ] Fazer deploy antes de 15 de maio.

Atenção a dois pontos:

  1. Raciocínio

Alguns modelos legados não aceitavam reasoning_effort. No Grok 4.3, o raciocínio está sempre ativo. Se seu fluxo dependia de baixa latência, teste low.

  1. Formato de saída

O Grok 4.3 tende a ser mais estruturado que o Grok 4.20. Se você usa regex rígida no pós-processamento, reteste.

Para comparação de preços em toda a linha OpenAI, consulte Preços do GPT-5.5. Para modelos de raciocínio diretos, veja Como usar a API do GPT-5.5.

Testando no Apidog

Uma forma prática de validar o Grok 4.3 é criar uma coleção com variações controladas.

1. Crie um ambiente

No Apidog, configure variáveis:

XAI_API_KEY = xai-...
BASE_URL = https://api.x.ai/v1
MODEL = grok-4.3
Enter fullscreen mode Exit fullscreen mode

2. Crie a requisição

Método:

POST {{BASE_URL}}/chat/completions
Enter fullscreen mode Exit fullscreen mode

Headers:

Authorization: Bearer {{XAI_API_KEY}}
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

Body:

{
  "model": "{{MODEL}}",
  "messages": [
    {
      "role": "system",
      "content": "Você é um engenheiro de backend sênior."
    },
    {
      "role": "user",
      "content": "Analise este erro de produção e sugira a causa provável: ..."
    }
  ],
  "reasoning_effort": "medium"
}
Enter fullscreen mode Exit fullscreen mode

3. Duplique a requisição em três variantes

Crie três versões:

  • reasoning_effort: "low"
  • reasoning_effort: "medium"
  • reasoning_effort: "high"

Compare:

  • Conteúdo da resposta
  • Latência
  • usage.prompt_tokens
  • usage.completion_tokens
  • usage.reasoning_tokens
  • usage.total_tokens

4. Compare com outro provedor

Você também pode criar uma variante com URL base da OpenAI para comparar modelos usando o mesmo prompt. A ideia é manter o corpo o mais parecido possível e trocar apenas provedor/modelo quando aplicável.

Baixe o Apidog para executar a comparação. Para uma estratégia mais ampla de testes de API, consulte Ferramenta de teste de API para engenheiros de QA.

Teste no Apidog

Limites de taxa

Os limites no Console da xAI variam conforme o nível da conta. Eles podem ir de alguns milhares de requisições por minuto no Nível 1 até centenas de milhares em níveis corporativos.

Como os números mudam, valide diretamente no painel do console.

A vazão de aproximadamente 159 tokens/segundo informada pela xAI é a velocidade de saída por stream, não a vazão agregada. Requisições concorrentes escalam dentro dos limites do seu nível.

Quando você atinge limite de taxa, a API retorna 429 com cabeçalho retry-after.

Exemplo simples de backoff:

import time
from openai import RateLimitError

for attempt in range(5):
    try:
        response = client.chat.completions.create(
            model="grok-4.3",
            messages=[
                {
                    "role": "user",
                    "content": "Explique este erro: ..."
                }
            ],
        )
        break
    except RateLimitError:
        sleep_seconds = 2 ** attempt
        time.sleep(sleep_seconds)
Enter fullscreen mode Exit fullscreen mode

FAQ

O Grok 4.3 é totalmente compatível com OpenAI?

Para Chat Completions, sim. Use o SDK da OpenAI, altere base_url para https://api.x.ai/v1 e mude model para grok-4.3.

Chamada de funções, saída estruturada e streaming usam formato compatível.

Ele suporta a Responses API?

A superfície da xAI hoje é Chat Completions. A Responses API é exclusiva da OpenAI.

Qual é o limite real de contexto?

1.000.000 de tokens.

Mesmo com preço menor, entradas longas têm custo relevante. Use cache quando o prompt for estável.

Como o raciocínio sempre ativo afeta a latência?

A latência do primeiro token pode ser maior do que em modelos sem raciocínio. Em compensação, o modelo transmite a saída a aproximadamente 159 tokens/segundo. Para tarefas sensíveis à precisão, o trade-off tende a ser aceitável.

Posso usar o Grok 4.3 com o Grok Voice?

Sim. O agente de voz grok-voice-think-fast-1.0 chama o Grok 4.3 internamente quando raciocina. Você também pode chamar o Grok 4.3 diretamente em um loop de voz próprio usando TTS e STT.

O que acontece com chamadas antigas do Grok 3 ou Grok 4 após 15 de maio?

Elas falharão com 410, indicando modelo desativado. Migre antes do prazo.

O Grok 4.3 suporta entrada de imagem?

Sim. Além da nova entrada de vídeo, ele também suporta imagem. Use uma URL de imagem em um bloco de conteúdo no formato compatível com OpenAI.

Conclusão

O Grok 4.3 combina redução de preço, contexto de 1M de tokens, raciocínio sempre ativo e entrada de vídeo nativa. Para equipes que já usam Chat Completions, a migração tende a ser uma troca de URL base e modelo, não uma reescrita completa.

O caminho mais rápido para validar:

  1. Crie três requisições no Apidog: low, medium e high.
  2. Use seus prompts reais.
  3. Compare latência, qualidade e reasoning_tokens.
  4. Atualize o modelo antes de 15 de maio.

Top comments (0)