Como usar a API do Grok 4.7? Faça a primeira chamada em 5 minutos

TL;DR

• Grok 4.7 é o modelo de texto da xAI voltado para codificação e tarefas agentic, já disponível na HiAPI; abra a página do modelo para conversar direto, e novos usuários ganham 200 créditos ao se registrar.
• Preço da plataforma: $0.84 de entrada / $2.52 de saída (por 1M tokens, leitura de cache $0.21), cerca de 58% de desconto sobre o preço oficial. Uma requisição de 2K de entrada + 1K de saída custa cerca de $0.0042; considerando uma requisição média de 3K tokens no total (cerca de $0.0084 por chamada), $10 permitem cerca de 1200 execuções.
• Chamada mais rápida: POST https://api.hiapi.ai/v1/chat/completions, com model definido como grok-4.7; no código atual com OpenAI SDK basta alterar os dois valores base_url e model.

O que é o Grok 4.7 e o que há de novo

Lançado em 2026-09-21, o Grok 4.7 é o modelo padrão recomendado atual da xAI, com foco em codificação, tarefas agentic e trabalho de conhecimento. O resultado autodeclarado no Terminal-Bench 4.0 subiu de 20,3% na versão 4.6 para 38,0%, quase o dobro (segundo dados autodeclarados). Para quem faz chamadas, há quatro mudanças relevantes:

• Codificação e agentic são os cenários principais: a empresa também o integrou a ferramentas de codificação como Cursor e GitHub Copilot; a capacidade de planejamento de tarefas de longo prazo é o destaque desta versão.
• Quatro níveis de raciocínio: reasoning_effort aceita low / medium / high / xhigh, padrão high; o processo de pensamento é devolvido separadamente no campo reasoning_content, para você decidir se deve exibi-lo.
• Objeto JSON + chamada de ferramentas: response_format: {"type": "json_object"} força saída JSON válida, e a chamada de funções usa o formato padrão OpenAI tools, sem necessidade de wrappers extras para extração estruturada e loops de agent.
• Contexto de 500K: uma requisição pode conter um repositório de código inteiro ou trechos extensos de documentação.

Resultado real: um trecho de código de análise de dados com pandas

O trecho abaixo foi obtido por nós executando o Grok 4.7 na HiAPI (o prompt completo está no link abaixo). A tarefa era analisar dados de pedidos de e-commerce: GMV mensal, Top 20 usuários por consumo acumulado e tendência do primeiro pedido de novos usuários, com created_at sendo string. O modelo concluiu em 18,5 segundos, com código completo e executável, tratando proativamente a conversão de datas em string:

# ---------- 0. Tratamento de datas: string para datetime ----------
df["created_at"] = pd.to_datetime(df["created_at"], errors="coerce")
df = df.dropna(subset=["created_at", "amount", "user_id"])

# Contar apenas pedidos válidos (ajuste os valores de status conforme o negócio real)
df_valid = df[df["status"] == "paid"].copy()

# ---------- 1. GMV e número de pedidos por mês ----------
df_valid["month"] = df_valid["created_at"].dt.to_period("M")
monthly = (
    df_valid.groupby("month", as_index=False)
    .agg(GMV=("amount", "sum"), order_count=("order_id", "count"))
    .sort_values("month")
)

Nesta execução real foram 3440 tokens de entrada e 1427 tokens de saída, cerca de $0.007 pelo preço da plataforma. Para obter o mesmo resultado, clique em executar este prompt uma vez na página do modelo →

Duas formas de começar

Caminho 1: navegador, 3 passos, sem código

1. Abra a página do modelo Grok 4.7, faça login ou registre-se (novos usuários ganham 200 créditos).
2. Cole seu prompt na caixa de diálogo; por exemplo, clique neste link, com o prompt já preenchido automaticamente.
3. Envie diretamente; os créditos são debitados conforme o uso real de tokens.

Caminho 2: API, 3 passos, integre ao seu aplicativo

1. Crie uma API Key no console da HiAPI.
2. Substitua YOUR_HIAPI_API_KEY no curl abaixo pela sua Key e execute.
3. Fixe model como grok-4.7, troque messages pela entrada do seu negócio e pronto.

curl: primeira chamada

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_HIAPI_API_KEY" \
  -d '{
    "model": "grok-4.7",
    "messages": [
      {"role": "system", "content": "You are a senior backend engineer."},
      {"role": "user", "content": "Explain what a database connection pool is in two sentences."}
    ],
    "reasoning_effort": "high",
    "max_tokens": 2000
  }'

Na resposta, choices[0].message.content é o texto principal e reasoning_content é o processo de pensamento; usage.completion_tokens_details.reasoning_tokens informa separadamente quantos tokens esta inferência consumiu. Para streaming, adicione "stream": true e analise via SSE.

Python: não streaming + streaming

Para não streaming, requests é suficiente:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [
            {"role": "user", "content": "Write a Python function that merges two sorted lists into one sorted list."}
        ],
        "reasoning_effort": "medium",
        "max_tokens": 4000,
    },
    timeout=120,
)
resp.raise_for_status()
data = resp.json()
print(data["choices"][0]["message"]["content"])

Atenção a dois pontos no streaming: o delta.reasoning_content que chega primeiro é o processo de pensamento, e só o delta.content posterior é o texto principal; o usage só aparece no último chunk (choices vazio), terminando com data: [DONE]:

import json
import requests

with requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [{"role": "user", "content": "Plan a Redis-based online presence system."}],
        "reasoning_effort": "high",
        "stream": True,
    },
    stream=True,
    timeout=300,
) as resp:
    resp.raise_for_status()
    for line in resp.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        payload = line[len("data:"):].strip()
        if payload == "[DONE]":
            break
        chunk = json.loads(payload)
        if not chunk["choices"]:
            print("\nusage:", chunk["usage"])  # usage só existe no último chunk
            continue
        delta = chunk["choices"][0]["delta"]
        if delta.get("reasoning_content"):
            print(delta["reasoning_content"], end="", flush=True)
        elif delta.get("content"):
            print(delta["content"], end="", flush=True)

Tabela de parâmetros

Campo	Obrigatório	Valores	Descrição
model	Sim	grok-4.7	Use sempre este ID
messages	Sim	Array de mensagens no formato OpenAI	Suporta os papéis system / user / assistant / tool
reasoning_effort	Não	low / medium / high / xhigh, padrão high	Intensidade de raciocínio; o processo de pensamento é devolvido em reasoning_content
max_tokens	Não	Inteiro positivo	Limite de saída, inclui reasoning tokens; se for muito pequeno, o pensamento é truncado antes
response_format	Não	{"type": "json_object"}	Força saída JSON válida, ideal para extração estruturada
tools	Não	Array de OpenAI function calling	Chamada de ferramentas, com suporte a devolução de resultados de tool em múltiplas rodadas
stream	Não	true / false, padrão false	Streaming via SSE; o usage fica no último chunk

Erros que você vai encontrar

A armadilha mais comum ao migrar código de outros modelos: o grok-4.7 não suporta os três parâmetros frequency_penalty, presence_penalty e stop; se forem incluídos, retorna 400 diretamente. reasoning_effort aceita apenas os quatro níveis low / medium / high / xhigh; com valor incorreto, a interface retorna exatamente reasoning_effort: is outside allowed values; campos fora do protocolo também não passam: em nossos testes, ao adicionar um campo não registrado, a interface retornou request.zz: unregistered public parameter.

A solução é simples: remova esses três parâmetros, corrija o nível e reenvie. Para outros 4xx, verifique primeiro error.code antes de mexer no código; não adivinhe.

Atenção antes de ir para produção

• reasoning tokens são cobrados como saída. No nível high, uma resposta pode incluir dezenas de milhares de tokens de processo de pensamento, cobrados a $2.52/M na fatura. Para tarefas simples, reduzir reasoning_effort para low ou medium é o interruptor de economia mais direto; usage.completion_tokens_details.reasoning_tokens permite conferir esse número separadamente.
• Requisições completas de 200K mudam de faixa. Quando o prompt atinge 200K tokens (limite contratual de 199,999), toda a requisição passa a ser cobrada pelo preço de texto longo: entrada $1.68 / saída $5.04 / leitura de cache $0.42, o dobro da faixa normal. Mantenha o tráfego regular abaixo de 200K e não despeje o repositório inteiro sem critério.
• A leitura de cache custa apenas um quarto do preço normal. Longos system prompts repetidos e prefixos de conversas multirodada acertam o cache automaticamente; a leitura de cache custa $0.21/M (um quarto do preço normal de $0.84/M). Em loops de agent, mantenha o prefixo estável e a fatura ficará visivelmente melhor.

Perguntas frequentes

Como escolher entre Grok 4.7 e Grok 4.6? O preço na plataforma é exatamente o mesmo ($0.84/$2.52). Para codificação complexa e tarefas agentic, escolha o 4.7 (recomendação padrão oficial); para tarefas simples em que se quer economizar tokens, pode manter o 4.6. Comparativo detalhado em Grok 4.7 vs Grok 4.6.

Suporta saída em streaming? Sim, SSE padrão. Observe que o usage só é retornado no último chunk; o usage dos chunks anteriores vem vazio.

O reasoning_content tem custo adicional? Não é preciso ativar nenhum interruptor separado, mas os reasoning tokens gerados entram no uso de saída e são cobrados pelo preço de saída; portanto, quanto maior o nível, maior a fatura.

O contexto de 500K é o limite de entrada? 500K é a janela total de entrada mais saída. Quando a entrada se aproxima de 200K, o preço de texto longo é acionado; veja detalhes em "Atenção antes de ir para produção" acima.

---

Para aprofundar: cálculo de preços em Quanto custa a API do Grok 4.7, 5 prompts de cenários prontos para copiar em Coletânea de prompts do Grok 4.7, e o uso da geração anterior na página do modelo Grok 4.6. Copie o prompt de pandas acima e faça sua primeira chamada na página do modelo.