xAI

Disponível

grok-4.6

Grok 4.6 API

Name: Grok 4.6 API
Brand: CometAPI
SKU: grok-4.6
Price: 2 USD
Availability: InStock

O modelo carro-chefe para código e tudo o mais: invocação de ferramentas com autonomia, alucinações mínimas, raciocínio configurável.

Preço inicial

$1.60 / 1M de tokens de entrada

Cobrança por uso

Status da API

Disponível

Endpoint de produção

Resposta

Pronto para assíncrono

Tempo de resposta da API observado

Lançado

Aug 12, 2026

xAI

Playground

Teste Grok 4.6 com uma solicitação real, revise os parâmetros e valide a saída antes de integrar a API.

Preços

Use a estimativa rápida acima para uma única execução e depois veja a comparação completa entre CometAPI e preço oficial.

Primeira solicitação

—

Custo estimado de uso da CometAPI

Dez solicitações

—

Custo estimado de uso da CometAPI

Quinze solicitações

—

Custo estimado de uso da CometAPI

Preços para Grok 4.6

Explore preços competitivos para Grok 4.6, projetado para atender diversos orçamentos e necessidades de uso. Nossos planos flexíveis garantem que você pague apenas pelo que usar, facilitando o dimensionamento conforme suas necessidades crescem. Descubra como Grok 4.6 pode aprimorar seus projetos mantendo os custos gerenciáveis.

Comet Price (USD / M Tokens)	Official Price (USD / M Tokens)	Discount
Entrada:$1.6/M Saída:$4.8/M	Entrada:$2/M Saída:$6/M	-20%

API

Copie um endpoint funcional e um exemplo de código, e abra a referência completa da API quando precisar de todos os parâmetros.

Uma API, acesso a modelos pronto para produção

Autentique-se uma vez, chame o endpoint do modelo e mantenha o mesmo fluxo de cobrança e observabilidade entre provedores.

POST/v1/chat/completionsPOST/v1/responses

Código de exemplo e API para Grok 4.6

Acesse código de exemplo abrangente e recursos de API para Grok 4.6 para otimizar seu processo de integração. Nossa documentação detalhada fornece orientação passo a passo, ajudando você a aproveitar todo o potencial do Grok 4.6 em seus projetos.

POST

/v1/chat/completions

POST

/v1/responses

#!/usr/bin/env bash
# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

response=$(curl --silent --location --request POST "https://api.cometapi.com/v1/responses" \
  --header "Authorization: Bearer $COMETAPI_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data-raw '{
    "model": "grok-4.6",
    "input": [
      {
        "role": "user",
        "content": "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}"
      }
    ]
  }')

if command -v jq >/dev/null 2>&1; then
  printf '%s
' "$response" | jq -r '(
    [
      .output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text
    ][0]
  ) // .output_text // .'
else
  printf '%s
' "$response"
fi

cURL Code Example

#!/usr/bin/env bash
# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

response=$(curl --silent --location --request POST "https://api.cometapi.com/v1/responses" \
  --header "Authorization: Bearer $COMETAPI_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data-raw '{
    "model": "grok-4.6",
    "input": [
      {
        "role": "user",
        "content": "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}"
      }
    ]
  }')

if command -v jq >/dev/null 2>&1; then
  printf '%s\n' "$response" | jq -r '(
    [
      .output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text
    ][0]
  ) // .output_text // .'
else
  printf '%s\n' "$response"
fi

Python Code Example

import os

from openai import OpenAI

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)
response = client.responses.create(
    model="grok-4.6",
    input=[
        {
            "role": "user",
            "content": "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}",
        }
    ],
)

print(response.output_text or response.model_dump_json(indent=2))

JavaScript Code Example

import OpenAI from "openai";

// Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
const apiKey = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const baseUrl = "https://api.cometapi.com/v1";

const client = new OpenAI({
  apiKey,
  baseURL: baseUrl,
});

const response = await client.responses.create({
  model: "grok-4.6",
  input: [
    {
      role: "user",
      content: "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}",
    },
  ],
});

console.log(response.output_text ?? JSON.stringify(response.output, null, 2));

Capacidades

Veja os principais dados do modelo antes de escolher uma arquitetura ou estimar a carga em produção.

Capacidades suportadas

Recursos retornados pela API do modelo existente.

text-to-text

image-to-text

Entrada e saída

Entradas

text

Saídas

text

Perfil de produção

Provedor: xAI
Contexto: Depende do modelo
Uso comercial: Suportado

Casos de uso

Use Grok 4.6 em fluxos de produção compatíveis com suas capacidades de text, e compare alternativas antes de um compromisso de integração de longo prazo.

Chat de produção e fluxos de trabalho com agentes

Programação, análise e geração estruturada

Automação de alto volume por meio de uma API

Outros modelos

Compare outros modelos disponíveis na CometAPI considerando qualidade, latência, capacidades e preço.

Abrir comparação de modelos →

DeepSeek

DeepSeek V4 Pro

DeepSeek V4 Pro é um modelo de Mixture-of-Experts em larga escala da DeepSeek, com 1.6T de parâmetros totais e 49B de parâmetros ativados, com suporte a uma janela de contexto de 1M tokens. Ele foi projetado para raciocínio avançado, programação e fluxos de trabalho de agentes de longo horizonte, com desempenho forte em benchmarks de conhecimento, matemática e engenharia de software.

Ver modelo

Anthropic

Claude Sonnet 5

Modelo de alto desempenho para programação e agentes

Ver modelo

Aliyun

Qwen3.8-Max

Qwen3.8-Max é o modelo de linguagem de grande porte principal da Alibaba Qwen, projetado para raciocínio avançado, fluxos de trabalho baseados em agentes, compreensão multimodal e aplicações de IA em escala empresarial. Ele possui 2.4T de parâmetros, adota a arquitetura MoE, suporta a alternância entre modos de raciocínio e de inferência rápida, consegue lidar com diversos formatos de conteúdo e apresenta desempenho excelente em cenários como engenharia de código, tarefas profissionais de escritório e raciocínio lógico complexo, ficando atrás apenas do Fable 5 da Anthropic.

Ver modelo

Anthropic

Claude Opus 5

Claude Opus 5 está disponível hoje. É um modelo ponderado e proativo que se aproxima da inteligência de ponta do Claude Fable 5 pela metade do preço.

Ver modelo

Anthropic

Claude Fable 5

O acesso ao Claude Fable 5 foi restabelecido. Ele traz inteligência de 5ª geração para seus projetos de programação e trabalhos profissionais mais ambiciosos.

Ver modelo

OpenAI

GPT 5.6

Comece com o GPT-5.6 Sol para raciocínio complexo e programação, escolha o GPT-5.6 Terra para equilibrar inteligência e custo ou use o GPT-5.6 Luna para cargas de trabalho sensíveis a custos e de alto volume.

Ver modelo

Uptime

Veja dados de heartbeat em tempo real, disponibilidade do endpoint e tempos de resposta observados antes de ir para produção.

Continue explorando

Compare modelos e continue sua pesquisa

Preços para Grok 4.6

Comet Price (USD / M Tokens)	Official Price (USD / M Tokens)	Discount
Entrada:$1.6/M Saída:$4.8/M	Entrada:$2/M Saída:$6/M	-20%

Código de exemplo e API para Grok 4.6

#!/usr/bin/env bash
# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

response=$(curl --silent --location --request POST "https://api.cometapi.com/v1/responses" \
  --header "Authorization: Bearer $COMETAPI_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data-raw '{
    "model": "grok-4.6",
    "input": [
      {
        "role": "user",
        "content": "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}"
      }
    ]
  }')

if command -v jq >/dev/null 2>&1; then
  printf '%s
' "$response" | jq -r '(
    [
      .output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text
    ][0]
  ) // .output_text // .'
else
  printf '%s
' "$response"
fi

cURL Code Example

#!/usr/bin/env bash
# Get your CometAPI key from https://www.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

response=$(curl --silent --location --request POST "https://api.cometapi.com/v1/responses" \
  --header "Authorization: Bearer $COMETAPI_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data-raw '{
    "model": "grok-4.6",
    "input": [
      {
        "role": "user",
        "content": "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}"
      }
    ]
  }')

if command -v jq >/dev/null 2>&1; then
  printf '%s\n' "$response" | jq -r '(
    [
      .output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text
    ][0]
  ) // .output_text // .'
else
  printf '%s\n' "$response"
fi

Python Code Example

import os

from openai import OpenAI

# Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)
response = client.responses.create(
    model="grok-4.6",
    input=[
        {
            "role": "user",
            "content": "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}",
        }
    ],
)

print(response.output_text or response.model_dump_json(indent=2))

JavaScript Code Example

import OpenAI from "openai";

// Get your CometAPI key from https://www.cometapi.com/console/token, and paste it here
const apiKey = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const baseUrl = "https://api.cometapi.com/v1";

const client = new OpenAI({
  apiKey,
  baseURL: baseUrl,
});

const response = await client.responses.create({
  model: "grok-4.6",
  input: [
    {
      role: "user",
      content: "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}",
    },
  ],
});

console.log(response.output_text ?? JSON.stringify(response.output, null, 2));