DEV Community: Lucas

Como Usar a API Seedance 2.0 em 2026

Lucas — Sat, 04 Apr 2026 13:01:01 +0000

Resumo

A API Seedance 2.0 foi lançada em 2 de abril de 2026, através da Volcengine Ark. Você envia uma tarefa de geração de vídeo com uma requisição POST e então consulta um endpoint GET até que o status atinja "succeeded" (bem-sucedido). A API suporta texto-para-vídeo, imagem-para-vídeo, controle de quadro inicial e final, referências multimodais e geração de áudio nativa. Um vídeo de 5 segundos em 1080p custa aproximadamente US$0,93. Faça o download do vídeo em até 24 horas. A URL expira depois disso.

Hypereal AI

Experimente Hypereal AI

Experimente o Apidog hoje

Introdução

Em 2 de abril de 2026, a plataforma Volcengine Ark da ByteDance lançou a API oficial do Seedance 2.0. Antes dessa data, a única forma de gerar vídeos Seedance 2.0 era através do console web. Se você viu tutoriais mostrando um passo a passo da interface do usuário, eles foram escritos para o console. Este guia cobre a API real que os desenvolvedores podem chamar programaticamente.

💡 Dica: A API segue um padrão de tarefa assíncrona: POST para criar a tarefa, receber o ID e então consultar um endpoint GET até que o trabalho termine. Este padrão deve ser testado de ponta a ponta antes de ir para produção. Os Cenários de Teste do Apidog permitem encadear o envio POST, extrair o ID, repetir consultas GET e afirmar que a resposta final contém uma URL de vídeo válida. Baixe o Apidog gratuitamente para seguir os passos de teste na seção sobre Apidog abaixo.

Este artigo cobre tipos de entrada suportados, cálculo de preços com base na resposta e os erros mais comuns na produção.

O que é Seedance 2.0?

Seedance 2.0 é um modelo de geração de vídeo da ByteDance, operando na Volcengine Ark sob os IDs de modelo doubao-seedance-2-0-260128 (padrão) e doubao-seedance-2-0-fast-260128 (rápido, menor qualidade).

Principais recursos:

Texto-para-vídeo e imagem-para-vídeo
Controle de quadro inicial e final (duas imagens)
Entradas de referência multimodais: imagens, vídeos e áudio em uma requisição
Geração de áudio nativa (diálogo, efeitos, música)
Sincronização labial em 8+ idiomas
Controle de movimento da câmera via prompt de linguagem natural
Duração de até 15 segundos, resolução até 2K

O modelo gera vídeos a 24fps, com proporções de 1:1 a 21:9. A resolução é configurável na requisição.

O que mudou: guia vs. API oficial

Guias anteriores, incluindo este guia de fevereiro de 2026, cobriam apenas o console web. Agora, com a API oficial, é possível integrar Seedance a pipelines automatizados e produtos próprios. Este artigo foca no uso direto via API, para desenvolvedores.

Pré-requisitos

Crie uma conta em volcengine.com.
Gere sua chave de API no console do Ark:

https://console.volcengine.com/ark/region:ark+cn-beijing/apikey

Exporte a chave como variável de ambiente:

export ARK_API_KEY="your-api-key-here"

Use o token Bearer em cada requisição:

Authorization: Bearer YOUR_ARK_API_KEY

Contas novas recebem créditos de teste (cobrem ~8 gerações de 15s em 1080p).

Texto-para-vídeo: sua primeira requisição

A URL base da API Seedance:

https://ark.cn-beijing.volces.com/api/v3

Para criar uma tarefa texto-para-vídeo: POST em /v1/contents/generations/tasks.

Exemplo de cURL

curl -X POST "https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
      }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false
  }'

A resposta retorna o id da tarefa:

{"id": "cgt-2025xxxxxxxx-xxxx"}

Exemplo em Python (SDK oficial)

Instale o SDK:

pip install volcenginesdkarkruntime

Envie uma tarefa:

import os
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

print(resp.id)

Guarde o id para a etapa de consulta.

Padrão de tarefa assíncrona: enviar, consultar, baixar

A geração não é instantânea. Um vídeo de 5s em 1080p leva 1-2 minutos. O ciclo:

queued -> running -> succeeded
                -> failed
                -> expired
                -> cancelled

Consulte o endpoint GET até o status sair de queued/running.

Loop de consulta em Python

import os
import time
import requests
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

# Passo 1: Enviar tarefa
resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {"type": "text", "text": "Aerial shot of a mountain lake at sunrise, slow dolly forward"}
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

task_id = resp.id
print(f"Tarefa enviada: {task_id}")

# Passo 2: Consultar status com backoff exponencial
wait = 10
while True:
    result = client.content_generation.tasks.get(task_id=task_id)
    status = result.status
    print(f"Status: {status}")

    if status == "succeeded":
        video_url = result.content.video_url
        print(f"URL do vídeo: {video_url}")
        break
    elif status in ("failed", "expired", "cancelled"):
        print(f"Tarefa terminou com status: {status}")
        break

    time.sleep(wait)
    wait = min(wait * 2, 60)

# Passo 3: Baixar vídeo
if status == "succeeded":
    response = requests.get(video_url, stream=True)
    with open("output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Baixado: output.mp4")

Use backoff exponencial para evitar sobrecarregar a API.

Imagem-para-vídeo (I2V): animando uma imagem

Para animar uma imagem estática, adicione um objeto image_url ao array content junto ao prompt de texto. A imagem vira o quadro inicial.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The woman slowly turns her head and smiles at the camera"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/portrait.jpg"}
        }
    ],
    ratio="adaptive",
    duration=5,
    watermark=False,
)

Use ratio="adaptive" para manter a proporção da imagem.
Imagens: até 30MB cada, máximo 9 por requisição.

Quadro inicial e final: controlando pontos de início e fim

Forneça duas imagens (primeiro e último quadro) mais o prompt de texto. O modelo faz a transição entre elas.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The flower blooms from bud to full open, macro lens, soft light"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-bud.jpg"}
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-open.jpg"}
        }
    ],
    ratio="adaptive",
    duration=8,
    watermark=False,
)

Inclua as imagens em ordem (primeiro depois último quadro). Para encadear clipes, use return_last_frame: true para obter a imagem do último quadro e alimentar na próxima requisição.

Referência multimodal: combinando imagens, vídeo e áudio

Seedance 2.0 permite enviar imagens, vídeos e áudio como referência na mesma tarefa.

Array de conteúdo pode conter:

{"type": "text", ...} para prompt
{"type": "image_url", ...} para imagens
{"type": "video_url", ...} para vídeos
{"type": "audio_url", ...} para áudio

Limites:

Até 9 imagens (<30MB cada)
Até 3 vídeos (2-15s, <50MB cada)
Até 3 áudios (MP3, <15MB cada)

Exemplo:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "Match the visual style of the reference clip and add the provided background audio"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/style-reference.jpg"}
        },
        {
            "type": "video_url",
            "video_url": {"url": "https://example.com/motion-reference.mp4"}
        },
        {
            "type": "audio_url",
            "audio_url": {"url": "https://example.com/background-music.mp3"}
        }
    ],
    duration=10,
    ratio="16:9",
    watermark=False,
)

Com referência de vídeo, o custo por token cai (~US$3,90/M tokens).

Geração de áudio nativa

Para gerar trilha de áudio junto ao vídeo, defina generate_audio: true.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A street musician plays guitar outside a cafe in Paris, crowds passing by, city sounds"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=10,
    generate_audio=True,
    watermark=False,
)

A geração de áudio cobre diálogos, efeitos, ambiente e música, com sincronização labial em vários idiomas. Isso aumenta um pouco o consumo de tokens.

Controlando resolução, proporção e duração

resolução: "480p", "720p", "1080p", "2K". Padrão: "1080p".
proporção: "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", "adaptive".
duração: inteiro de 4 a 15 (segundos). Padrão: 5.

O modelo rápido (doubao-seedance-2-0-fast-260128) é útil para prototipagem. Use o padrão para produção.

Prefira Seedance 2.0 para geração áudio-vídeo conjunta, controle de quadros e referências multimodais. Para T2V simples e barato, use o modelo rápido em 480p.

Lendo o custo da resposta

Após sucesso, a resposta inclui:

{
  "usage": {
    "completion_tokens": 246840,
    "total_tokens": 246840
  }
}

Referências:

15s 1080p ≈ 308.880 tokens
5s 1080p ≈ 102.960 tokens

Preço:

T2V/I2V 1080p: 46 yuans/M tokens (~US$6,40/M tokens)
V2V: 28 yuans/M tokens (~US$3,90/M tokens)

Exemplo:

5s 1080p: ≈ 102.960 tokens ≈ US$0,93
10s 1080p: ≈ 205.920 tokens ≈ US$1,97

Multiplique completion_tokens pela taxa do tipo de tarefa para rastreamento de custos.

Importante: baixe o vídeo em até 24 horas

A video_url expira 24h após o status "succeeded". Após isso, retorna erro 403 e o arquivo é perdido.

Baixe o arquivo imediatamente após sucesso. Consulte o campo execution_expires_after para o tempo de expiração da tarefa (em segundos), mas a URL segue a regra das 24h.

O histórico de tarefas só guarda os últimos 7 dias.

Como testar a API Seedance com Apidog

O padrão assíncrono envolve múltiplas chamadas dependentes. Use Cenários de Teste do Apidog para automatizar:

Passos práticos

1. Crie um Cenário de Teste

No módulo Testes do Apidog, crie o cenário "Geração de vídeo Seedance 2.0".
Defina a variável de ambiente ARK_API_KEY.

2. Adicione a requisição de envio

POST para https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks
Cabeçalho: Authorization: Bearer {{ARK_API_KEY}}
Corpo JSON com modelo e conteúdo

Após enviar, extraia o id do corpo usando JSONPath $.id e salve como variável TASK_ID.

3. Adicione processador de Espera

Processador "Wait" de 30s após extração do ID.

4. Adicione a consulta em loop

Bloco For (máx 20 iterações):
1. GET para /contents/generations/tasks/{{TASK_ID}}
2. "Wait" de 10s após GET
3. Quebre o loop se $.status == "succeeded" ou $.status == "failed"

5. Adicione asserções

Após o loop, afirme que:
- $.status é "succeeded"
- $.content.video_url não está vazio

Execute o cenário. O Apidog mostra relatório detalhado de cada etapa, ID extraído, respostas e assertivas finais.

Você pode importar endpoints Seedance por comando cURL para agilizar a criação do cenário.

Detalhamento de preços: quanto custa um vídeo de 10 segundos

A cobrança é por uso (tokens):

Tipo de tarefa	Taxa (por 1M tokens)
T2V / I2V em 1080p	46 yuans (~US$6,40)
V2V (referência de vídeo)	28 yuans (~US$3,90)

Exemplos para 1080p:

Duração	Tokens aprox.	Custo (T2V/I2V)
5 segundos	~103.000	~$0,66 yuan / ~$0,93
10 segundos	~206.000	~$9,48 yuan / ~$1,32
15 segundos	~309.000	~$14,21 yuan / ~$1,97

Contas novas recebem créditos de teste (~8 gerações de 15s). Use 720p no desenvolvimento para economizar tokens.

Erros comuns e correções

429 Muitas Requisições: Limite de concorrência. Use backoff exponencial (espere 10s, dobre, limite a 60s).
status: "failed": Prompt violou filtros, imagem corrompida, parâmetros inválidos. Revise arquivos e tente novamente.
status: "expired": Tarefa ficou muito tempo na fila. Reenvie.
403 na video_url: URL expirada. Geração antiga (>24h). Reenvie a tarefa.
Reprodutibilidade com seed: Salve o seed da resposta e use para tentar gerar o mesmo vídeo novamente.

Conclusão

A API Seedance 2.0 permite automação completa de geração de vídeos avançados. O fluxo POST -> consulta -> download é simples de implementar. Suporte a multimodalidade, áudio nativo e controle de quadros habilita fluxos de trabalho impossíveis via console web.

Implemente sua cobertura de testes no Apidog antes de ir para produção. O uso de Cenários de Teste identifica problemas de consulta, extração ou expiração de URL antes que impactem os usuários.

Perguntas Frequentes

P: Qual a diferença entre doubao-seedance-2-0-260128 e doubao-seedance-2-0-fast-260128?

O modelo padrão gera vídeos com qualidade superior, indicado para produção. O modelo rápido é útil para prototipagem, com menor qualidade.

P: Posso usar o Seedance 2.0 fora da China?

Sim, mas o endpoint fica em Pequim. Fora da China, haverá maior latência. Confira os termos da Volcengine para restrições regionais.

P: Como encadear vários clipes em um vídeo mais longo?

Use return_last_frame: true para obter o último quadro. Passe como quadro inicial da próxima tarefa. Junte os clipes depois.

P: A geração de áudio nativa custa mais?

Sim, pois gera áudio e vídeo conjuntamente. Espere um aumento modesto em completion_tokens.

P: Posso definir um webhook em vez de polling?

Sim. Passe callback_url na requisição POST. A API fará POST para essa URL ao concluir a tarefa.

P: O que acontece se eu exceder 9 imagens?

A API retorna erro 400. Reduza para 9 ou menos.

P: O parâmetro seed garante reprodução idêntica?

Ajuda a reproduzir a saída, mas não garante identidade se parâmetros ou versão do modelo mudarem.

P: Como rastrear gastos em várias tarefas?

Leia o campo completion_tokens de cada resposta, multiplique pela taxa do seu tipo de tarefa e salve num banco de dados próprio. Não há painel integrado na API.

Como Usar a API Grok Text to Video: Guia Completo

Lucas — Fri, 03 Apr 2026 08:44:33 +0000

Resumo

A API de texto para vídeo Grok transforma prompts de texto em vídeos. Para utilizá-la, envie uma requisição POST /v1/videos/generations, receba um request_id imediatamente e consulte GET /v1/videos/{request_id} até que o status seja "done". O modelo utilizado é o grok-imagine-video, com preços a partir de US$0,05 por segundo em 480p. O SDK Python da xAI gerencia o polling automaticamente.

Experimente o Apidog hoje mesmo

Introdução

Em janeiro de 2026, a xAI gerou 1,2 bilhão de vídeos apenas no primeiro mês após o lançamento da API de texto para vídeo Grok (28/01/2026). O modelo liderou o ranking da Artificial Analysis nesse período, comprovando sua robustez em escala.

Este guia mostra como fazer sua primeira requisição, consultar o resultado, ajustar parâmetros, criar prompts melhores, usar imagens de referência, estender/editar vídeos e decidir quando usar texto para vídeo.

💡 Dica importante: A API é assíncrona. Seu frontend precisa lidar com polling para saber quando o vídeo está pronto. O Smart Mock da Apidog permite simular os endpoints de geração e consulta, acelerando o desenvolvimento do frontend antes do backend real.

O que é a API de texto para vídeo Grok?

A API de texto para vídeo Grok integra o conjunto de geração de mídia da xAI (https://api.x.ai). Basta enviar um prompt textual para o modelo grok-imagine-video — ele cria um clipe do zero, sem exigir imagem de origem.

Além disso, há um endpoint síncrono para geração de imagens (POST /v1/images/generations, modelo grok-imagine-image, US$0,02 por imagem), além de operações para estender ou editar vídeos.

No endpoint de texto para vídeo, só o texto importa: a cena, o movimento e o visual são definidos pelo prompt. Se você quiser animar uma imagem específica, consulte o guia da API de imagem para vídeo Grok.

Como funciona a geração de texto para vídeo (padrão assíncrono na prática)

A geração de vídeo é assíncrona devido ao tempo de processamento (segundos a minutos). O fluxo padrão:

Envie um POST com seu prompt.
Receba um request_id imediatamente.
A geração ocorre nos servidores da xAI.
Consulte GET /v1/videos/{request_id} periodicamente.
Quando o status for "done", a resposta traz a URL do vídeo.

Seu frontend precisa exibir um estado de carregamento até receber a URL final.

Pré-requisitos

Antes de codificar:

1. Conta na xAI: Cadastre-se em console.x.ai.

2. Chave de API: No console, crie sua chave em "API Keys" e salve-a com segurança. Ela será usada como Bearer Token em todas as requisições.

export XAI_API_KEY="sua_api_key_aqui"

(Opcional) Instale o SDK Python da xAI:

pip install xai-sdk

Sua primeira requisição de texto para vídeo

Endpoint: POST https://api.x.ai/v1/videos/generations. Campos obrigatórios: model e prompt.

Usando curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Um golden retriever correndo entre folhas de outono em câmera lenta, iluminação cinematográfica"
  }'

Resposta imediata:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Usando Python (requests)

import requests
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "model": "grok-imagine-video",
    "prompt": "Um golden retriever correndo entre folhas de outono em câmera lenta, iluminação cinematográfica"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=payload
)

data = response.json()
request_id = data["request_id"]
print(f"Geração iniciada. ID da Requisição: {request_id}")

Consultando o resultado do vídeo

Após obter o request_id, faça polling em GET /v1/videos/{request_id} até status ser "done".

"processing": em geração
"done": vídeo pronto (URL disponível)
"failed": erro na geração

Exemplo de loop de polling em Python:

import requests
import time
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

def poll_video(request_id: str, interval: int = 5, max_attempts: int = 60) -> dict:
    url = f"{BASE_URL}/v1/videos/{request_id}"

    for attempt in range(max_attempts):
        response = requests.get(url, headers=headers)
        data = response.json()

        status = data.get("status")
        progress = data.get("progress", 0)
        print(f"Tentativa {attempt + 1}: status={status}, progresso={progress}%")

        if status == "done":
            return data
        elif status == "failed":
            raise RuntimeError(f"Falha na geração do vídeo: {data}")

        time.sleep(interval)

    raise TimeoutError(f"Vídeo não pronto após {max_attempts} tentativas")

def generate_video(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/v1/videos/generations",
        headers={**headers, "Content-Type": "application/json"},
        json={"model": "grok-imagine-video", "prompt": prompt}
    )
    request_id = response.json()["request_id"]
    print(f"ID da Requisição: {request_id}")

    result = poll_video(request_id)
    video_url = result["video"]["url"]
    print(f"Vídeo pronto: {video_url}")
    return video_url

video_url = generate_video(
    "Um timelapse de um horizonte urbano ao pôr do sol fazendo a transição para a noite, vista aérea"
)

Exemplo de resposta quando o vídeo está pronto:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 500000000
  }
}

Usando o SDK Python da xAI

O SDK simplifica o processo — client.video.generate() já faz o polling e bloqueia até a conclusão.

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

result = client.video.generate(
    model="grok-imagine-video",
    prompt="Um golden retriever correndo entre folhas de outono em câmera lenta",
    duration=8,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"URL do Vídeo: {result.video.url}")
print(f"Duração: {result.video.duration}s")

Use o SDK para integração rápida. Para maior controle (intervalo de polling, lógica de retentativa), prefira requests diretas.

Escrevendo prompts eficazes para vídeo

Prompts detalhados geram melhores resultados.

Descrição da cena

Seja específico. Exemplo:

"Uma caneca de café de cerâmica branca em uma mesa de madeira ao lado de uma janela molhada pela chuva"

Movimento

Explique o que se move e como:

"A câmera orbita lentamente a caneca enquanto o vapor sobe em espiral"

Estilo de câmera

Comandos como "close-up", "plano de acompanhamento", "vista aérea de drone", "câmera na mão", "dolly zoom" funcionam bem.

Iluminação e humor

Combine clima e iluminação:

"manhã enevoada, atmosfera melancólica"

Referências de estilo

Cite estilos: "cinemático", "anime", "stop-motion", "documentário", etc.

Estrutura de prompt eficiente

Exemplo completo:

Um astronauta solitário flutua pela Estação Espacial Internacional,
com o cabo flutuando atrás dele. A câmera acompanha lentamente
ao lado, mostrando a Terra abaixo. Cinemático, qualidade IMAX,
luz quente do nascer do sol refletindo no visor.

Controlando resolução, duração e proporção

Personalize os parâmetros de saída:

Duração

"duration": 10

1 a 15 segundos (padrão: 6s). Quanto maior, maior o custo.

Resolução

"resolution": "720p"

Opções: "480p" (padrão) e "720p". Use 480p para testes.

Proporção de tela

"aspect_ratio": "9:16"

Proporção	Melhor uso
`16:9`	Desktop, YouTube, apresentações
`9:16`	TikTok, Reels, mobile
`1:1`	Instagram Feed, cartões sociais
`4:3`	Vídeo clássico, apresentações
`3:4`	Conteúdo mobile vertical
`3:2`	Foto padrão
`2:3`	Fotografia em retrato

Exemplo completo

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Uma cidade costeira ao amanhecer, ondas quebrando suavemente em uma costa rochosa",
    "duration": 10,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Usando imagens de referência para guiar o estilo

O parâmetro reference_images recebe até 7 URLs de imagem. Elas influenciam a estética do vídeo.

{
  "model": "grok-imagine-video",
  "prompt": "Uma cidade costeira ao amanhecer, ondas quebrando suavemente em uma costa rochosa",
  "reference_images": [
    {"url": "https://example.com/my-style-reference.jpg"},
    {"url": "https://example.com/color-palette-reference.jpg"}
  ]
}

Para melhores resultados, use imagens com estética visual coesa.

Diferencie:

Imagens de referência: influenciam estilo (cor, textura).
Imagem para vídeo: anima uma imagem de origem, que vira o primeiro frame.

Estendendo e editando vídeos gerados

Dois endpoints extras:

Estender um vídeo

POST /v1/videos/extensions — passar o request_id do vídeo original + novo prompt para gerar sequência adicional.

Editar um vídeo

POST /v1/videos/edits — modificar um vídeo existente via prompt textual (alterar estilo, efeitos, etc).

Ambos seguem o mesmo padrão assíncrono: retornam request_id e polling para resultado.

Lendo o custo da resposta da API

No resultado da consulta:

"usage": {
  "cost_in_usd_ticks": 500000000
}

Converta para dólares dividindo por 10.000.000:

cost_in_usd = result["usage"]["cost_in_usd_ticks"] / 10_000_000
print(f"Custo: ${cost_in_usd:.4f}")
# Saída: Custo: $0.0500

Referência de Preços

Resolução	Preço por segundo	Clipe de 10s
480p	$0.05	$0.50
720p	$0.07	$0.70

Monitore cost_in_usd_ticks para construir dashboards de uso sem precisar das APIs de faturamento.

Como testar sua API de vídeo Grok com Apidog

O padrão assíncrono exige que o frontend trate três estados: carregando, sucesso e erro. Testar tudo isso com a API real é demorado e caro. O recurso Smart Mock do Apidog resolve esse problema.

Caso de uso 1: Smart Mock para frontend

Simule o endpoint de geração: Crie POST /v1/videos/generations e defina o schema na Apidog, com campo request_id. O Smart Mock retorna um UUID fake automaticamente.

Exemplo de resposta:

   {
     "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
   }

Simule o endpoint de consulta: Crie GET /v1/videos/{request_id} com todos os campos (status, video.url, etc). Configure mocks customizados para "status": "done" e uma URL de vídeo fake.

Exemplo de resposta:

   {
     "status": "done",
     "video": {
       "url": "https://vidgen.x.ai/mock-video-12345.mp4",
       "duration": 8,
       "respect_moderation": true
     },
     "progress": 100,
     "usage": {
       "cost_in_usd_ticks": 400000000
     }
   }

Frontenders podem testar todos os estados sem consumir créditos reais.

Caso de uso 2: Cenários de Teste para o loop de polling

Adicione requisição de geração:

POST /v1/videos/generations, extraia request_id usando JSONPath.
Adicione loop de consulta:

GET /v1/videos/{{videoRequestId}} dentro de loop com condição: response.body.status == "done". Adicione espera de 5s entre as requisições.
Afirme o resultado:

Após o loop, afirme que $.video.url não está vazio.

Automatize esses cenários para garantir confiabilidade contínua na sua integração.

Texto para vídeo vs imagem para vídeo: quando usar cada um

Ambos usam grok-imagine-video, mas para usos distintos.

Use texto para vídeo quando:

Precisa de conteúdo 100% original a partir de um conceito/roteiro
Quer controle criativo total do modelo
Usuários digitarão prompts
Não tem imagem de origem

Use imagem para vídeo quando:

Quer animar uma foto, ilustração ou arte de marca
Precisa manter detalhes visuais exatos
Vai animar uma sequência de imagens relacionadas

Texto para vídeo cria do zero; imagem para vídeo parte de uma imagem. Para detalhes, veja o guia da API de imagem para vídeo Grok.

Para apps híbridos: se usuário faz upload de imagem, use POST /v1/images/generations. Se só texto, use POST /v1/videos/generations.

Erros comuns e como corrigir

401 Não Autorizado:

Verifique se o header Authorization está correto: Bearer SUA_CHAVE_XAI
Confirme se a chave está ativa

429 Muitas Requisições:

Respeite o limite: 60 por minuto, 1 por segundo
Use delays de 5s no polling

status: "failed":

Prompt rejeitado pela moderação. Veja se respect_moderation é true e ajuste o texto.

URL retorna 404:

URLs de vídeo expiram. Baixe o arquivo assim que receber a URL.

Vídeo vazio ou travado:

Prompts vagos geram vídeos sem movimento. Sempre inclua instruções de movimento.

Polling lento:

720p e durações maiores demoram mais. Para desenvolvimento, use "resolution": "480p" e clipes curtos.

Conclusão

A API de texto para vídeo Grok permite ir do texto ao vídeo de forma simples: envie o prompt, obtenha o request_id, faça polling até concluir e recupere o MP4. O fluxo assíncrono é o ponto central do processo. Uma vez automatizado o polling, ajustar os demais parâmetros é simples.

Para produção, monitore custos via cost_in_usd_ticks em cada resposta. Simule endpoints com Apidog para acelerar o desenvolvimento frontend e use Cenários de Teste para garantir confiabilidade.

Experimente o Apidog hoje mesmo para configurar mocks e cenários de teste para a API de vídeo Grok.

FAQ

Qual nome de modelo devo usar para geração de texto para vídeo?

Use grok-imagine-video no campo model da requisição POST para /v1/videos/generations.

Quanto tempo leva para gerar um vídeo?

Depende da duração e resolução. Em 480p, clipes curtos podem ficar prontos em menos de 30s. Em 720p e clipes longos, pode levar minutos. Faça polling a cada 5-10s.

Posso gerar vídeos com mais de 15 segundos?

Não em uma única requisição (duration máxima: 15s). Para vídeos maiores, gere um clipe e use POST /v1/videos/extensions.

Como baixar o vídeo gerado?

Use a URL retornada em result.video.url e baixe o MP4 imediatamente. A URL é temporária.

O que acontece se meu prompt violar moderação?

O status será "failed". Veja o campo respect_moderation. Ajuste o prompt e tente novamente.

Existe nível gratuito?

A xAI cobra por segundo gerado. Não há nível gratuito específico para vídeo, mas consulte console.x.ai para ofertas de crédito para novas contas.

Como reference_images diferem de imagem de origem?

reference_images apenas orientam o estilo; imagem de origem é o primeiro frame do vídeo.

Como testar o loop de polling sem gastar créditos?

Use o Smart Mock da Apidog para simular endpoints de geração e consulta, com respostas para "processing" e "done". Assim, o frontend funciona sem consumir a API real.

Como Usar a API de Imagem para Vídeo da Grok: Guia Passo a Passo

Lucas — Fri, 03 Apr 2026 08:39:21 +0000

Em Resumo

A API Grok de imagem para vídeo utiliza o modelo grok-imagine-video para animar uma imagem estática em um clipe de vídeo. Basta enviar um POST com a URL da sua imagem, um prompt e configurações para https://api.x.ai/v1/videos/generations. O retorno inclui um request_id para você consultar (polling) via GET /v1/videos/{request_id} até que o status seja "done". A geração leva de 1 a 15 segundos de vídeo, com preço a partir de US$ 0,05/seg para 480p.

Experimente o Apidog hoje

Introdução

Em 28 de janeiro de 2026, a xAI lançou o modelo grok-imagine-video para acesso público via API. No primeiro mês, o modelo gerou 1,2 bilhão de vídeos, liderando o ranking de texto para vídeo da Artificial Analysis. Com a funcionalidade de imagem para vídeo, você envia uma foto e um prompt descritivo via API, e recebe um vídeo animado pronto para download em MP4.

O fluxo assíncrono, onde você envia a tarefa e faz polling até a conclusão, exige testes reais. A integração só está finalizada quando o seu loop de polling trata corretamente os estados "processing", "done" e "failed".

Os Cenários de Teste do Apidog resolvem esse fluxo: encadeie o POST para /v1/videos/generations, extraia o request_id, faça polling até status == "done", e afirme que a URL do vídeo foi retornada. Siga o passo a passo de teste mais abaixo neste guia.

O que é a API Grok de imagem para vídeo?

A API Grok de imagem para vídeo é parte do produto de geração de vídeo da xAI, operando com o modelo grok-imagine-video. Ela recebe uma imagem que se torna o quadro inicial do vídeo. O modelo analisa a imagem e o prompt de texto, gerando movimento natural na cena.

Endpoint:

POST https://api.x.ai/v1/videos/generations

Autenticação:

Authorization: Bearer SUA_CHAVE_API_XAI

Sua chave está disponível no console da xAI. O mesmo endpoint suporta texto para vídeo (sem o parâmetro image), extensão e edição de vídeo.

Como funciona o processo de imagem para vídeo

O parâmetro image define o primeiro quadro do vídeo. O modelo parte dessa imagem (não a substitui) e prevê como ela se moveria conforme o prompt.

Exemplo:

Imagem: lago ao nascer do sol

Prompt: "ondulações suaves se espalham pela água enquanto a névoa matinal se move"

O primeiro quadro será a foto enviada; os quadros seguintes trazem a animação conforme o prompt.

Use imagem para vídeo quando:

Precisa animar fotos reais de produtos, paisagens ou retratos.
Quer manter identidade visual no quadro inicial.
Deseja movimento realista a partir de uma cena específica.

Prefira texto para vídeo quando:

Não tem imagem de referência.
Quer liberdade total na composição.
Precisa de iteração rápida.

Pré-requisitos

Antes de começar:

Conta xAI no console.x.ai
Chave de API do console xAI (mantenha em variável de ambiente)
Python 3.8+ ou Node.js 18+ (exemplos para ambos)
Imagem publicamente acessível (URL) ou codificada em base64 (data URI)

Defina a variável de ambiente:

export XAI_API_KEY="sua_chave_aqui"

Instale o SDK Python:

pip install xai-sdk

Para HTTP direto, use apenas requests (Python) ou fetch (Node.js).

Fazendo a primeira requisição de imagem para vídeo

Usando curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Resposta esperada:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

A geração é assíncrona. Use o request_id para polling.

Usando Python (requisições diretas)

import os
import requests

api_key = os.environ["XAI_API_KEY"]

payload = {
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
}

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api.x.ai/v1/videos/generations",
    json=payload,
    headers=headers
)

data = response.json()
request_id = data["request_id"]
print(f"Job started: {request_id}")

Usando uma imagem base64

Se a imagem não estiver pública:

import base64

with open("my_image.jpg", "rb") as f:
    encoded = base64.b64encode(f.read()).decode("utf-8")

payload["image"] = {
    "url": f"data:image/jpeg;base64,{encoded}"
}

Consultando o resultado (Polling)

A geração é assíncrona. Faça polling do status:

GET https://api.x.ai/v1/videos/{request_id}

Status possíveis:

Status	Significado
`"processing"`	Vídeo sendo gerado
`"done"`	Vídeo pronto, URL disponível
`"failed"`	Erro na geração

Exemplo de resposta:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 6
  },
  "progress": 100
}

Loop de polling em Python

import time

def poll_video(request_id: str, api_key: str, interval: int = 5) -> dict:
    url = f"https://api.x.ai/v1/videos/{request_id}"
    headers = {"Authorization": f"Bearer {api_key}"}

    while True:
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")

        print(f"Status: {status} | Progress: {data.get('progress', 0)}%")

        if status == "done":
            return data["video"]
        elif status == "failed":
            raise RuntimeError(f"Video generation failed for {request_id}")

        time.sleep(interval)

# Uso
video = poll_video(request_id, api_key)
print(f"Video URL: {video['url']}")
print(f"Duration: {video['duration']}s")

Dica: Use intervalo de polling ≥5s. A API limita a 60 requisições/minuto.

Usando o SDK Python da xAI

O xai-sdk faz o polling automaticamente:

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

video = client.video.generate(
    model="grok-imagine-video",
    prompt="Gentle waves move across the surface, morning mist rises slowly",
    image={"url": "https://example.com/landscape.jpg"},
    duration=6,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {video.url}")
print(f"Duration: {video.duration}s")

Prefira SDK para código limpo. Use HTTP direto para controle total de polling.

Controlando resolução, duração e proporção da tela

Duração

"duration": 10

Aceita 1 a 15 segundos. Quanto maior, maior o custo.

Resolução

Valor	Descrição
`"480p"`	Padrão. Mais barato, mais rápido
`"720p"`	Alta qualidade. US$ 0,07/seg

"resolution": "720p"

Proporção da tela (aspect_ratio)

Valor	Uso
"16:9"	Padrão, paisagens
"9:16"	Stories, vertical
"1:1"	Instagram, miniatura
"4:3"	Fotografia, apresentação
"3:4"	Retrato
"3:2"	Fotografia padrão
"2:3"	Retrato alto

Se enviar uma imagem, o padrão é a proporção da imagem. Defina explicitamente para cortar/padronizar.

Usando imagens de referência para estilo

O parâmetro reference_images é um array de até 7 imagens para guiar estilo, conteúdo ou contexto. Não são quadros do vídeo, apenas referência visual.

Exemplo de uso:

{
  "model": "grok-imagine-video",
  "prompt": "A product rotating slowly on a clean white surface",
  "image": {
    "url": "https://example.com/product-shot.jpg"
  },
  "reference_images": [
    {"url": "https://example.com/brand-style-reference-1.jpg"},
    {"url": "https://example.com/lighting-reference.jpg"}
  ],
  "duration": 6,
  "resolution": "720p"
}

Você pode omitir image e usar apenas reference_images para guiar um texto para vídeo.

Estendendo e editando vídeos

Estender um vídeo

Use:

POST /v1/videos/extensions

Adicione segundos a um vídeo existente (máx. 15s por chamada):

curl -X POST https://api.x.ai/v1/videos/extensions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "seu_request_id_original",
    "prompt": "The mist continues to lift as sunlight breaks through",
    "duration": 5
  }'

Faça polling do novo request_id normalmente.

Editar um vídeo

Use:

POST /v1/videos/edits

Altere conteúdo ou animação guiado por prompt:

curl -X POST https://api.x.ai/v1/videos/edits \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "seu_request_id_original",
    "prompt": "Change the sky to a dramatic sunset with deep orange tones"
  }'

Extensões e edições seguem o mesmo padrão assíncrono de polling.

Detalhes de preços: quanto custa um vídeo de 10 segundos

Componente	Custo
Imagem de entrada	US$ 0,002 por imagem
Saída 480p	US$ 0,05/seg
Saída 720p	US$ 0,07/seg

Exemplo:

10s em 720p: Imagem = US$ 0,002; Saída = 10×US$ 0,07 = US$ 0,70.

Total: US$ 0,702
6s em 480p: Imagem = US$ 0,002; Saída = 6×US$ 0,05 = US$ 0,30.

Total: US$ 0,302

A cobrança da imagem se aplica em toda geração, mesmo para a mesma imagem.

Como testar sua integração com a API Grok usando Apidog

O padrão assíncrono exige testar:

Requisição POST retorna request_id
Polling trata status "processing"
Resposta final tem status == "done" e URL de vídeo válida

Cenários de Teste do Apidog permitem automatizar esse fluxo:

Passo 1: Crie novo cenário de teste

No Apidog, acesse Testes > Novo cenário: "Fluxo assíncrono de imagem para vídeo Grok".

Passo 2: Adicione a requisição de geração

URL: https://api.x.ai/v1/videos/generations
Método: POST
Header: Authorization: Bearer {{xai_api_key}}
Corpo:

  {
    "model": "grok-imagine-video",
    "prompt": "Gentle mist rises from the water as light filters through the trees",
    "image": {
      "url": "https://example.com/your-test-image.jpg"
    },
    "duration": 6,
    "resolution": "480p"
  }

Passo 3: Extraia o request_id

Processador: Extrair Variável
Nome: video_request_id
Origem: Corpo da resposta
JSONPath: $.request_id

Passo 4: Loop de polling

Processador: Loop For
Dentro do loop:
- GET https://api.x.ai/v1/videos/{{video_request_id}}
- Extrair variável: video_status ($.status)
- Esperar: 5000ms
- Condição de parada: {{video_status}} == "done"

Passo 5: Afirmação da URL

GET final
Asserção: $.video.url não está vazio

Rodando o cenário

Clique em Executar para rodar o fluxo. O Apidog executa POST, extrai ID, faz polling e verifica a URL do vídeo. O relatório mostra status e tempo de cada etapa.

Integre ao CI/CD:

apidog run --scenario grok-video-async-flow --env production

Erros comuns e soluções

401 Não Autorizado: Cheque o header Authorization e a chave no console xAI.
422 Entidade Não Processável: Verifique se o corpo está correto, prompt não vazio, e imagem acessível.
Imagem não acessível: Use uma URL pública ou base64; evite localhost e URLs privadas.
Status travado em "processing": Pode levar até alguns minutos. Se passar de 10 minutos, tente novamente.
Limite de taxa 429: Respeite 60 req/minuto, 1 req/segundo. Use sleep(1) no polling paralelo.
Upload base64 rejeitado: Confirme prefixo do data URI (ex: data:image/jpeg;base64,).
Aspect ratio incompatível: Se diferente da imagem, pode haver corte/barras pretas. Ajuste para corresponder.

Conclusão

A API Grok de imagem para vídeo permite transformar fotos em clipes animados via POST + polling, baixando o MP4 ao final. O modelo grok-imagine-video liderou em janeiro de 2026, com mais de 1 bilhão de vídeos gerados. O polling assíncrono é o maior desafio; use Cenários de Teste do Apidog para garantir robustez na integração (extração de variável, loop, asserção de URL).

Comece a construir sua integração com Apidog gratuitamente. Não é necessário cartão de crédito.

FAQ (Perguntas Frequentes)

Qual modelo utilizar?

grok-imagine-video no campo model.

Diferença entre image e reference_images?

image: define o primeiro quadro.

reference_images: guia estilo/tema, não é quadro do vídeo.

Tempo de geração?

6s em 480p: 1~3 min.

15s em 720p: 4~8 min.

Poll a cada 5s.

Posso usar imagem local?

Sim, codifique como base64: data:image/jpeg;base64,{bytes}.

O que acontece sem aspect_ratio?

Com imagem, usa proporção da imagem. Sem imagem, padrão é 16:9.

Preço de 10s em 720p?

Imagem: US$ 0,002; Saída: 10×US$ 0,07 = US$ 0,70.

Total: US$ 0,702.

Limites de taxa?

60 requisições/minuto, 1 por segundo (POST e GET combinados).

Posso estender vídeos além de 15s?

Sim, usando POST /v1/videos/extensions e múltiplas chamadas, sempre via polling.

Links para Apidog mantidos conforme solicitado.

Quanto custa a API SMS da Bird em 2026? Preços e custos

Lucas — Fri, 03 Apr 2026 07:09:24 +0000

TL;DR

A API Bird SMS começa em $0,00331 por mensagem enviada nos EUA e $0,003 por mensagem recebida nos EUA. É um dos preços iniciais mais baixos entre os principais provedores de API de SMS. Você pode usar o plano gratuito para testar com até 5 SMS/dia antes de se comprometer. O plano Pro, por $49/mês, inclui 1.000 créditos de SMS.

Experimente o Apidog hoje

Introdução

A MessageBird virou Bird em 2023, trazendo um foco maior em comunicação omnichannel com IA: SMS, WhatsApp, e-mail e voz em um só lugar. O modelo de precificação é transparente, com tarifas pay-as-you-go que deixam o custo base de SMS da Bird abaixo de Twilio, Vonage e outros grandes players.

💡 Se você está construindo uma integração SMS, precisa de dados de precificação atualizados e uma forma ágil de testar suas chamadas de API antes de ir para produção. O Apidog cobre ambos: projete requisições, rode cenários de teste e valide respostas sem codar nada extra. Teste gratuitamente e valide sua integração Bird SMS em poucos minutos.

Este artigo mostra em detalhes quanto custa o Bird SMS em 2025 e 2026, o que pode aumentar sua fatura e como ele se compara a alternativas do mercado.

Visão geral de preços do Bird SMS

A precificação do Bird para SMS tem duas partes:

Taxa de assinatura do plano de plataforma (mensal)
Taxa por mensagem (pay-as-you-go além do plano)

Os planos são:

Plano	Custo mensal	SMS incluídos
Grátis	$0	5 SMS/dia
Pro	$49	1.000 SMS/mês
Empresarial	Personalizado	Volume personalizado

Se passar do limite do plano, você paga por mensagem:

SMS enviados (EUA): $0,00331 por mensagem
SMS recebidos (EUA): $0,003 por mensagem

Os preços de CRM/Automação de Marketing aparecem em EUR na página de taxas detalhadas, mas os valores em USD aqui são para o nível de API/desenvolvedor. Sempre confira a tabela atualizada em bird.com/en/pricing/sms, porque taxas de operadora e câmbio podem variar.

Detalhes de preços: SMS, MMS, WhatsApp e e-mail

SMS

O SMS de saída dos EUA custa $0,00331/mensagem. Essa é a taxa base da infraestrutura da Bird, que conecta direto a operadoras em 150+ países. Os valores mudam bastante dependendo do país. Exemplos (aproximados):

País	Taxa de envio
Estados Unidos	~$0.00331
Reino Unido	~€0.036
Austrália	~€0.009
Alemanha	~€0.056
Índia	varia por rota
Brasil	~€0.047

Atenção: Mensagens nos EUA e Canadá têm taxas extras de operadora (10DLC/toll-free), cobradas além do valor base.

MMS

MMS (mensagens com imagem) custa mais caro que SMS. Suporte a MMS existe para números dos EUA/Canadá. O valor gira em torno de 3x a 5x o SMS, dependendo do plano. Consulte bird.com/en/pricing/sms para tarifas MMS por país.

No WhatsApp, a cobrança tem dois componentes:

Taxa de processamento Bird (por 1.000 mensagens):

| Volume | Taxa por 1.000 mensagens |
|------------------|-------------------------|
| 1 a 1.000 | $0.001 |
| 1.001 a 100.000 | $0.005 |
| 100.001 a 500.000| $0.0045 |
| 500.001+ | $0.004 |

Taxa de repasse Meta (por conversa, varia por país/tipo):

Marketing: $0,0250
Utilidade: $0,0034
Autenticação: $0,0034

O Bird repassa as taxas da Meta sem acréscimo.

E-mail

O envio de e-mails via API começa em $0,001 por mensagem para volumes baixos, reduzindo conforme o volume cresce. O plano Pro já traz 10.000 e-mails/mês. É o canal mais barato da plataforma.

Voz

O preço da API de Voz é por uso e muda por país. Chamadas de saída dos EUA custam entre $0,013–$0,015/minuto. Chamadas de entrada são um pouco mais baratas. Para grandes volumes, negocie diretamente com vendas.

O que afeta sua conta da Bird

Veja os principais fatores que influenciam o custo final:

1. País e roteamento da operadora

O SMS nos EUA custa $0,00331, mas enviar para Alemanha (~€0,056), Bangladesh (~€0,208) ou Burundi (~€0,269) pode ficar 10-80x mais caro. Sempre consulte a tabela de preços por país antes de planejar envios internacionais.

2. Tipo de número

O tipo de número afeta o custo:

Códigos longos (10DLC): Números padrão EUA. Exigem registro de marca/campanha pelo The Campaign Registry (TCR).
Códigos curtos: De 5-6 dígitos, throughput maior. Aluguel mensal elevado ($500–$1.000/mês).
Toll-free: Intermediário, custo mensal baixo, throughput moderado.

O aluguel do número é cobrado além das mensagens.

3. Comprimento da mensagem e codificação

SMS padrão = 160 caracteres (GSM-7). Se passar disso, é segmentado e cada segmento é cobrado. Caracteres Unicode (emojis, acentos, scripts não latinos) limitam para 70 caracteres por segmento. Um emoji em mensagem longa pode gerar 3 cobranças em vez de 2.

4. Combinação de canais

Se usar fallback via WhatsApp quando SMS falhar, você terá cobranças de WhatsApp. O Flow Builder facilita esses fluxos, mas simule os custos antes de ativar.

5. Volume

A Bird não publica descontos por volume para SMS, mas o plano Enterprise oferece tarifas sob consulta para grandes volumes. Negocie conforme a necessidade.

Custos e taxas ocultos

Apesar do discurso de preços transparentes, fique atento a itens que podem aumentar a conta:

Taxas de operadora dos EUA (10DLC)

O sistema 10DLC exige:

Registro de marca: Taxa única ($4–$44)
Registro de campanha: Mensal (~$10/mês/campanha)
Sobretaxa por mensagem: Centavos extras por mensagem

Esses valores são definidos pelas operadoras, não pelo Bird.

Aluguel de número de telefone

Códigos longos (EUA): $1–$2/mês
Toll-free: $2–$3/mês
Códigos curtos: $500–$1.000/mês

Webhooks de entrada e processamento

Receber SMS ativa a cobrança de entrada ($0,003/mensagem nos EUA). Se usar automações de opt-out ou palavras-chave, cada resposta conta.

Assinatura da plataforma

O plano Pro ($49/mês) é fixo. O excedente é cobrado por mensagem. Em alto volume, os 1.000 SMS incluídos podem ser pouca coisa.

Como a Bird se compara às alternativas

Comparativo das taxas de SMS de saída nos EUA:

Provedor	SMS saída EUA	SMS entrada EUA	Observações
Bird	$0,00331	$0,003	Taxa base mais baixa; plataforma omnichannel
Twilio	$0,0079	$0,0079	Base mais alta; ecossistema vasto
Telnyx	~$0,004	~$0,001	Competitiva; conexão direta com operadora
Plivo	$0,0055	$0,0005	Menor entrada; plataforma mais simples

A Bird lidera no custo base por mensagem de saída nos EUA. Twilio cobra mais que o dobro, mas oferece descontos em altíssimo volume. Telnyx é competitiva, com modelo direto operador-cliente. Bird se destaca para quem precisa SMS, WhatsApp e e-mail integrados e automação em uma única plataforma.

Como começar com a Bird

Crie uma conta gratuita: Acesse bird.com. O plano gratuito libera 5 SMS/dia sem cartão de crédito.
Registre sua marca/campanha: Pelo painel da Bird, registre-se para conformidade 10DLC. O processo leva 1–3 dias úteis.
Obtenha um número de telefone: Provisione um número de código longo via API de Números ou painel.
Faça sua primeira chamada de API: Use a API REST (JSON). Exemplo básico de envio via curl:

   curl -X POST "https://rest.bird.com/messages" \
     -H "Authorization: AccessKey SUA_CHAVE_DE_API" \
     -H "Content-Type: application/json" \
     -d '{
       "originator": "SEU_NUMERO",
       "recipients": ["+15551234567"],
       "body": "Seu código de verificação: 123456"
     }'

A documentação completa (docs.bird.com) cobre autenticação, SDKs (Node.js, Python, PHP, Go, Java, Ruby) e configuração de webhooks.

Conclusão

A Bird SMS API oferece a menor taxa base entre os principais provedores: $0,00331 por mensagem enviada nos EUA. O plano gratuito permite testar sem cartão de crédito. O plano Pro ($49/mês) atende equipes que estão começando, com 1.000 SMS/mês inclusos.

Fique atento a custos fora do preço por mensagem: taxas de operadora 10DLC, aluguel de número e tarifas internacionais (que podem ser 50x maiores que EUA). Modele seu custo desde o início.

Se for avaliar a Bird, use o Apidog para testar a integração ponta a ponta antes da produção. Ele cuida da montagem de requisições, variáveis de ambiente, encadeamento de testes e validações, tudo em um único lugar.

FAQ

Qual é o preço por mensagem da API Bird SMS nos EUA?

$0,00331 por SMS enviado; $0,003 por SMS recebido (nível API). Taxas adicionais de operadora (10DLC) se aplicam.

Bird é o mesmo que MessageBird?

Sim. MessageBird foi renomeada para Bird em 2023. A empresa existe desde 2011 (Holanda) e atende grandes clientes. Algumas documentações ainda referenciam MessageBird.

A Bird cobra por SMS de entrada?

Sim, $0,003 por mensagem de entrada nos EUA. Respostas de opt-out e palavras-chave também contam.

Qual é o plano gratuito da Bird?

Inclui 5 SMS/dia, 10 e-mails/dia e 15 mensagens de agente IA/dia. API pública, sem cartão de crédito. Ideal para testar antes do upgrade.

Como o preço da Bird SMS se compara ao Twilio?

Bird: $0,00331 (saída EUA); Twilio: $0,0079. Para 100.000 mensagens, Bird = $331; Twilio = $790 (preços base). Twilio pode dar descontos em grandes volumes.

Existem taxas ocultas no Bird SMS?

Sim: taxas de registro de marca/campanha 10DLC, sobretaxas de operadora por mensagem, aluguel de número ($1–$2/mês), tarifas internacionais mais altas.

Como testar a API Bird SMS sem enviar mensagens reais?

Use o recurso Smart Mock do Apidog para simular respostas da API Bird durante o desenvolvimento. Também é possível enviar para número verificado usando sandbox da Bird. No Apidog, você pode encadear requisições e validar campos de resposta sem tocar em produção.

Preço SMS Twilio API: Análise Completa de Custos para 2026

Lucas — Fri, 03 Apr 2026 03:56:36 +0000

TL;DR

SMS de código longo dos EUA (saída e entrada): $0,0083 por mensagem
MMS de saída: $0,022 por mensagem; MMS de entrada: $0,0165 por mensagem
SMS gratuito (toll-free): $0,0083 por mensagem mais sobretaxas da operadora
Aluguel de código curto: $1.000/mês para um código aleatório; $1.500/mês para um código personalizado (vanity)
Registro de marca 10DLC: $4,50 taxa única (atualizado em agosto de 2025); campanhas de $1,50 a $10/mês
Número de telefone (código longo): $1,15/mês; gratuito (toll-free): $2,15/mês
As taxas da operadora se somam a todos os preços base
Descontos por volume são aplicados automaticamente a partir de 150.000 mensagens por mês
Teste gratuito disponível; não é necessário cartão de crédito para começar

Introdução

Twilio é a API de SMS padrão para a maioria das equipes de desenvolvedores. Sua documentação é completa, o tempo de atividade é confiável e a API REST é bem projetada. Mas, uma vez que você passa de um projeto paralelo para um aplicativo em produção, a fatura cresce rapidamente. Você não está pagando um preço único por mensagem. Você está pagando a taxa base do Twilio, uma taxa de operadora, uma taxa de número de telefone e, possivelmente, os custos de registro 10DLC adicionais.

Experimente o Apidog hoje

💡 Dica prática: Antes de construir sua integração de SMS, teste-a adequadamente. O Apidog permite criar cenários de teste automatizados para validar respostas do webhook do Twilio conforme sua especificação OpenAPI. Confirme códigos de status, valide schemas de resposta e rode testes de contrato no CI/CD. Experimente o Apidog gratuitamente para garantir seus fluxos de SMS antes de irem para produção.

Este artigo detalha cada item na precificação do Twilio. Entenda o que compõe sua fatura, pontos fáceis de passar despercebidos e compare com alternativas.

Visão geral dos preços de SMS do Twilio

Twilio utiliza um modelo de preços pay-as-you-go (pague pelo que usar). Você paga por segmento de mensagem, por número de telefone/mês e por recursos opcionais ou registros. Não há contratos ou mínimos obrigatórios, exceto se negociar desconto por uso comprometido.

Taxa base para SMS nos EUA (código longo): $0,0083 por segmento de mensagem (entrada e saída). Mas taxas de operadora, aluguel de número e registro de conformidade são adicionados a cada mês.

Descontos por volume são automáticos a partir de 150.000 mensagens/mês por tipo de número.

Detalhes da precificação: SMS, MMS, números gratuitos e códigos curtos

SMS de código longo (números de 10 dígitos)

Códigos longos são os números padrão de 10 dígitos para mensagens A2P nos EUA.

Tipo de mensagem	Preço por segmento
SMS de saída	$0,0083
SMS de entrada	$0,0083
MMS de saída	$0,022
MMS de entrada	$0,0165

Atenção ao cálculo: O Twilio cobra por segmento de mensagem (não por mensagem). Um segmento SMS padrão: 160 caracteres GSM-7. Com Unicode (emojis, acentos), 70 caracteres por segmento. Exemplo prático: mensagem de 200 caracteres = 2 segmentos cobrados.

Números gratuitos (Toll-free)

Mesma taxa base de SMS dos códigos longos: $0,0083/segmento (entrada e saída).
MMS de saída: $0,022; MMS de entrada: $0,02.
Não requerem registro 10DLC, mas exigem verificação para throughput máximo.

Quando usar: Para alto volume e envio unidirecional sem precisar de 10DLC.

Códigos curtos (números de 5-6 dígitos)

Ideais para campanhas de alto volume. SMS: $0,0083/mensagem, porém custo fixo mensal elevado.

Tipo de código curto	Custo mensal
Código curto aleatório	$1.000/mês (trimestral)
Código curto personalizado	$1.500/mês (trimestral)
Vanity próprio (BYOV)	$500/mês (trimestral)

Taxa única de $500 para MMS habilitado em qualquer código curto.

Descontos por volume

Descontos automáticos por faixa para códigos longos, toll-free e códigos curtos:

Mensagens/mês	Preço por segmento
1 a 150.000	$0,0083
150.001 a 300.000	$0,0081
300.001 a 500.000	$0,0079
500.001 a 750.000	$0,0077
750.001 a 1.000.000	$0,0075
1.000.001+	$0,0073

O volume é separado para cada tipo de número. Não é possível combinar códigos longos e toll-free para desconto.

O que afeta sua fatura do Twilio

Tipo de número de telefone

A tabela de tarifas depende do tipo de número (código longo, toll-free, código curto). Dividir tráfego entre tipos pode impedir atingir descontos em qualquer faixa.

Segmentos de mensagem

Mensagens longas ou com Unicode geram múltiplos segmentos, aumentando o custo real.

Taxas de operadora

Além da taxa base Twilio, cada grande operadora dos EUA acrescenta uma sobretaxa por mensagem.

Taxas de operadora para código longo (SMS de saída):

Operadora	Taxa de saída
AT&T	$0,0035
T-Mobile	$0,0045
Verizon	$0,004
US Cellular	$0,005
Outras	$0,004

Para MMS, taxas ainda maiores (AT&T: $0,009 por MMS; T-Mobile: $0,01).
Exemplo: SMS de saída para AT&T = $0,0083 (Twilio) + $0,0035 (operadora) = $0,0118 por segmento.

País de destino

Preços internacionais variam bastante: Reino Unido $0,04/mensagem; Índia $0,0029; Brasil $0,075. Baixe a tabela completa no site Twilio.

Registro 10DLC

Obrigatório para quem envia SMS A2P por código longo nos EUA. Sem registro, as mensagens podem ser bloqueadas pelas operadoras.

Custos e taxas ocultos

Taxas de registro 10DLC

Atualizadas em agosto de 2025 (TCR):

Marca Proprietário Individual/Low Volume: $4,50 taxa única
Marca padrão: $46 taxa única
Verificação padrão: $41,50
Verificação adicional: $11
Reenvio Authentication Plus: $12,50 por tentativa

Taxas de campanha:

Tipo de campanha	Mensal
Proprietário Individual	$2
Mista de baixo volume	$1,50
Padrão	$10
Caridade/501(c)(3)	$3
Serviços de emergência	$5

Taxa de verificação única: $15/campanha

Taxas de número de telefone

Código longo: $1,15/mês
Toll-free: $2,15/mês
Provisione múltiplos números? Multiplique o custo.

Taxa de processamento de mensagem falha

$0,001 por mensagem com status "Falha". Pode surpreender em testes ou alta filtragem.

Add-ons opcionais

Engagement Suite (encurtamento de link/rastreamento): $0,015/mensagem saída após 1.000/mês gratuitos.
Compliance Toolkit (conformidade via IA): $0,015/mensagem saída.

Planos de suporte

Gratuito é limitado.
Planos pagos a partir de $250/mês ("Developer"). Necessário para produção crítica.

Como o Twilio se compara às alternativas

Provedor	SMS saída (EUA)	SMS entrada (EUA)	Número de telefone	10DLC exigido
Twilio	$0,0083 + taxas operadora	$0,0083 + taxas operadora	$1,15/mês	Sim
Plivo	$0,005	$0,00035	$0,80/mês	Sim
Telnyx	$0,004	$0,004	$1,00/mês	Sim
Bird	~$0,007	~$0,007	Varia	Sim

Plivo e Telnyx normalmente mais baratos por mensagem.
Twilio se destaca em documentação, experiência dev e integrações. Para uso intensivo e baixo custo, avalie Telnyx/Plivo.

Como testar o Twilio gratuitamente

Crie conta de teste no Twilio (sem cartão de crédito).
Receba créditos gratuitos para testes reais.
Mensagens para números não verificados exibem prefixo "Enviado de sua conta de teste Twilio".
Upgrade remove o prefixo.
Teste prático inclui:
- Provisionamento de número de teste
- Envio/recebimento de SMS via API
- Teste de webhooks para mensagens de entrada
- Exploração do Console e logs

No upgrade, pague só o que usar. Não há mínimo mensal no pay-as-you-go.

Como testar sua integração SMS do Twilio com o Apidog

Configure suas credenciais e webhooks Twilio, mas valide a integração com testes automatizados do Apidog para evitar erros de payload e inconsistências em produção.

Passo a passo prático com Apidog

Importe a especificação OpenAPI do endpoint de webhook do Twilio para o Apidog.
Monte o cenário de teste: adicione etapas para envio de SMS, recebimento de callback, resposta de entrada.
Orquestre as etapas: reordene e execute em sequência automatizada.
Encadeie dados: use {{$.stepId.response.body.field}} para passar SIDs entre etapas.
Valide contratos: defina o schema do payload do webhook e o Apidog compara automaticamente as respostas contra a especificação:
- Confere códigos de status HTTP
- Verifica presença de campos obrigatórios
- Garante tipos corretos (SID como string, timestamps formatados)
- Bloqueia campos extras não permitidos

Tudo isso sem escrever scripts de asserção personalizados.

Para começar:

Baixe o Apidog gratuitamente.
Importe a especificação da API do Twilio ou defina o schema do webhook.
Crie um cenário de teste que simule o fluxo completo de SMS (envio e recebimento).

Conclusão

Os preços de SMS do Twilio iniciam em $0,0083 por segmento (código longo EUA), mas o custo real inclui taxas de operadora, aluguel de número e registro 10DLC. Um SMS para AT&T sai por cerca de $0,0118/segmento. Para campanhas 10DLC padrão, adicione $10/mês por campanha.

A precificação é transparente e os descontos por volume são automáticos, mas é essencial considerar todos os itens e não só a taxa principal.

Após modelar seus custos, implemente sua integração e teste de ponta a ponta. Os Cenários de Teste e o Teste de Contrato do Apidog validam seus webhooks Twilio e asseguram que as respostas estejam em conformidade com a especificação, sem necessidade de código de teste customizado.

FAQ

P: Qual é o preço base para um SMS de saída nos EUA no Twilio?

R: A taxa base do Twilio é de $0,0083 por segmento de mensagem para SMS de saída de código longo dos EUA. As taxas da operadora são adicionadas. Uma mensagem da AT&T adiciona $0,0035, tornando o custo real $0,0118 por segmento para essa operadora.

P: O Twilio cobra por SMS de entrada?

R: Sim. O Twilio cobra $0,0083 por segmento para SMS de entrada em códigos longos e números gratuitos (toll-free). Taxas de operadora também podem ser aplicadas, dependendo da operadora de origem.

P: O que é 10DLC e eu preciso pagar por isso?

R: 10DLC é o sistema de registro dos EUA para SMS A2P enviados de códigos longos de 10 dígitos. Se você está enviando mensagens geradas por aplicativo para consumidores dos EUA em um código longo, você deve se registrar. O registro da marca custa $4,50 (taxa única). As taxas de campanha variam de $1,50 a $10/mês, dependendo do tipo de campanha.

P: Quanto custa um código curto do Twilio?

R: Um código curto aleatório custa $1.000/mês, cobrado trimestralmente. Um código curto personalizado (um número que você escolhe) custa $1.500/mês. Ambos exigem uma taxa de configuração única de $500 se habilitados para MMS. Os códigos curtos usam a mesma taxa de SMS por mensagem de $0,0083.

P: O Twilio oferece descontos por volume?

R: Sim, automaticamente. As primeiras 150.000 mensagens por mês por tipo de número custam $0,0083 cada. A taxa cai por seis níveis até $0,0073 para mais de um milhão de mensagens por mês. Descontos por uso comprometido para empresas também estão disponíveis entrando em contato com as vendas.

P: Existe um teste gratuito para o Twilio?

R: Sim. O Twilio oferece uma conta de teste gratuita com créditos incluídos. Não é necessário cartão de crédito para se inscrever. Contas de teste podem enviar e receber mensagens SMS reais, embora as mensagens de saída incluam um prefixo de teste até que você faça o upgrade.

P: Qual é a alternativa mais barata ao Twilio para SMS?

R: Plivo e Telnyx oferecem taxas por mensagem mais baixas que o Twilio. A taxa de saída de SMS dos EUA do Plivo é de $0,005 por mensagem e a de entrada é de $0,00035. O Telnyx cobra $0,004 por mensagem. Ambos exigem registro 10DLC para tráfego A2P nos EUA. O Twilio tende a oferecer melhor documentação, suporte e cobertura de recursos para casos de uso mais complexos.

Quanto Custa a API SMS da Vonage? Preços 2026

Lucas — Fri, 03 Apr 2026 03:50:13 +0000

TL;DR

O preço da API SMS da Vonage começa em US$ 0,00809 por mensagem de saída e US$ 0,00649 por mensagem de entrada nos EUA. Não há mínimo mensal: você paga apenas pelo que enviar e receber. Tarifas internacionais variam conforme o país e podem passar de US$ 1,00 por mensagem em alguns mercados. Se você está desenvolvendo ou testando integração SMS da Vonage, o Apidog facilita o envio de requisições de teste, validação de respostas e detecção de erros antes do deploy do seu código.

Experimente o Apidog hoje

Introdução

Se você já ouviu falar da Nexmo, você já conhece a Vonage. Em 2016, a Vonage adquiriu a Nexmo, uma plataforma de API de SMS e comunicação voltada para desenvolvedores. A marca Nexmo permaneceu em uso e você ainda verá o developer.vonage.com (antigo nexmo.com/developers) como hub técnico. Em 2022, a Ericsson finalizou a aquisição da Vonage, mantendo a marca para o negócio de APIs.

Hoje, a Vonage atende mais de 100.000 empresas e 1,6 milhão de desenvolvedores registrados. É uma plataforma madura, com modelo pay-as-you-go, sem contrato ou fidelidade, com cobertura em mais de 190 países.

💡 Antes de avançar com sua integração, é fundamental contar com uma ferramenta eficiente de teste de API. O Apidog permite criar cenários de teste para requisições SMS da Vonage, validar respostas, e encadear múltiplas chamadas de API em um fluxo de trabalho. Experimente gratuitamente, sem necessidade de cartão de crédito.

Visão geral de preços SMS da Vonage

A Vonage opera com modelo pay-as-you-go para a API SMS. Não existe taxa de plataforma ou mensalidade, apenas cobrança por mensagem enviada ou recebida, variando conforme país e tipo de número.

Principais tarifas nos Estados Unidos:

Tipo de mensagem	Preço por mensagem
SMS de saída (LVN EUA)	$0.00809
SMS de entrada (LVN EUA)	$0.00649
SMS de saída (Toll-Free EUA)	Contatar vendas
SMS de entrada (Toll-Free EUA)	Grátis

LVN (Local Virtual Number) é o termo da Vonage para número virtual local (10DLC). As tarifas são por país e a plataforma calcula o valor em tempo real, conforme uso.

A Vonage disponibiliza uma planilha global de preços, baixável pelo painel Nexmo/Vonage, cobrindo todos os países para planejamento de custos internacionais.

Detalhamento de preços: saída, entrada, MMS e WhatsApp

SMS de saída

Mensagens enviadas do seu app para o usuário final. Nos EUA, US$ 0,00809 por mensagem usando número virtual local. Consulte sempre o painel oficial para tarifas atualizadas.

SMS de entrada

Mensagens recebidas em um número alugado na Vonage. Nos EUA, US$ 0,00649 por mensagem de entrada. Alguns números Toll-Free recebem SMS gratuitamente, mas confirme no painel antes de depender disso.

Preços de MMS

MMS é suportado via API de Mensagens, mas a Vonage não divulga tarifa fixa publicamente. É necessário contatar vendas, pois depende de acordos com operadoras.

WhatsApp via Vonage

A Vonage oferece WhatsApp via API de Mensagens. Existem duas cobranças:

Taxa do WhatsApp: Cobrança pelo Meta, variando conforme a categoria da conversa.
Taxa da Vonage: A partir de US$ 0,00015 por mensagem, variando conforme categoria e volume.

Facebook Messenger

Mensagens do Facebook Messenger são US$ 0,0011 por mensagem entregue via API de Mensagens.

RCS (Serviços de Comunicação Rica)

A Vonage suporta RCS com tarifas por operadora nos EUA:

Operadora	RCS Rich (texto)	RCS Rich Media
T-Mobile	$0.00620	$0.01250
Verizon	$0.00400	$0.00600
AT&T	$0.00450	$0.01000
US Cellular	$0.00620	$0.01350

Há taxa única de configuração de US$ 600 por país para RCS.

O que afeta sua conta Vonage

Conheça os principais fatores que alteram sua fatura mensal:

País de destino

O país é o maior fator de custo. EUA tem tarifas baixas, mas mercados com menor conectividade podem custar US$ 0,50 ou mais por SMS. Sempre consulte a planilha global antes de enviar internacionalmente.

Tipo de número

Nos EUA, existem:

Código longo (10DLC): Local e acessível, bom para P2P e app-to-person.
Números Toll-Free: Maior throughput para A2P, entrada geralmente gratuita.
Códigos curtos: Alto volume, requer aprovação prévia.

Cada tipo tem tarifas e custos de aluguel diferentes.

Taxas de aluguel de número

Alugar um número virtual custa extra. Números locais iniciam em poucos dólares/mês; Toll-Free e short codes são mais caros.

Codificação de mensagem

SMS padrão: 160 caracteres (GSM-7). Com Unicode (emoji, acentos), o limite cai para 70. Uma mensagem Unicode de 200 caracteres conta como três mensagens – atenção para não triplicar custos!

Sobretaxas de operadora

Operadoras dos EUA aplicam sobretaxas, especialmente em mensagens A2P via 10DLC. A Vonage repassa essas taxas e elas aparecem detalhadas na fatura.

Custos ocultos a serem observados

Além do custo por mensagem, fique atento a:

Níveis de suporte

Grátis: fóruns e docs.
Comercial: plano pago.
Premium: suporte 24/7 e gerente de conta por US$ 3.300/mês. Necessário para operações críticas.

APIs complementares

Complemento	Custo mensal
Audit API	$550/mês
Auto-redação (remoção de PII)	$1.100/mês
Reports API	$495/mês (ou $0.00049/CDR avulso)

A Audit API é essencial para compliance. Auto-redação remove PII dos logs.

Custos da Verify API

A autenticação 2FA via Verify API custa US$ 0,0572 por verificação bem-sucedida (mais taxas de mensagens/voz). Verificações com falha ainda geram custos.

Registro de número (10DLC EUA)

Para SMS A2P nos EUA com códigos longos, é obrigatório registrar campanha no TCR. Custos:

Taxa única de registro de marca
Taxa mensal por campanha

Sem registro, as mensagens são filtradas.

Vonage vs. Alternativas

Comparativo de preços de SMS de saída nos EUA:

Provedor	SMS saída EUA	SMS entrada EUA	Teste Grátis	Suporte
Vonage	$0.00809	$0.00649	Sim (só números verificados)	Níveis pagos; $3.300/mês para 24/7
Twilio	$0.0079	$0.0075	Sim ($15 de crédito)	Pago a partir de $250/mês
Plivo	$0.0055	$0.0005	Sim	Básico grátis; níveis pagos
Telnyx	$0.004	$0.002	Sim ($5 de crédito)	Email 24/7 grátis; telefone pago

Observações rápidas:

Telnyx é a mais barata nos EUA, mas é uma plataforma mais recente.
Plivo tem preços competitivos e boa reputação.
Twilio lidera em ecossistema, integrações e documentação, mas é mais cara.
Vonage tem preço intermediário, com respaldo e confiabilidade da Ericsson.

O preço por mensagem não é tudo: avalie taxas de entrega, compliance, ferramentas de desenvolvimento e qualidade do suporte.

Como experimentar a Vonage gratuitamente

A Vonage oferece conta de teste gratuita.

O que você recebe

Número virtual para testes de envio/recebimento
Credenciais de API (key e secret)
Acesso à documentação completa e SDKs
Créditos de teste para envio limitado

Restrições

Durante o teste, só é possível enviar SMS para números cadastrados/verificados na conta, como prevenção a fraudes. O envio para números externos exige upgrade.

Passo a passo para começar

Acesse dashboard.nexmo.com ou vonage.com/communications-apis
Crie uma conta gratuita via e-mail
Verifique seu número de telefone
Pegue a chave e segredo da API no painel
Faça a primeira chamada de API usando a REST API ou SDK oficial

SDKs disponíveis: Node.js, Python, PHP, Ruby, Java, .NET, Go. Ou use qualquer cliente HTTP para chamar a REST API.

Como testar sua integração SMS da Vonage com o Apidog

Com chave e segredo da Vonage, utilize o Apidog para testar sua integração antes de ir para produção.

O módulo de Cenários de Teste do Apidog permite encadear múltiplas requisições de API em um fluxo automatizado, simulando o ciclo real: envio de SMS, verificação de status, manipulação de erro.

Como configurar um cenário de teste

No Apidog:

Acesse o módulo Testes e crie um novo cenário.
Adicione etapas:
- Importe da especificação da sua API (OpenAPI)
- Adicione requisição personalizada para o endpoint REST da Vonage
- Importe comando cURL da documentação

Exemplo de requisição básica de SMS:

POST https://rest.nexmo.com/sms/json
Content-Type: application/x-www-form-urlencoded

api_key=SEU_API_KEY
api_secret=SEU_API_SECRET
from=REMETENTE
to=DESTINATARIO
text=Sua mensagem de teste

Validando a resposta

O Apidog valida automaticamente conforme o schema. Para a API SMS da Vonage, a resposta de sucesso inclui um array messages. Cada item tem um campo status. status=0 indica sucesso.

Adicione asserções para:

Código HTTP 200
messages[0].status igual a "0"
messages[0].message-id não vazio

Se receber erro (status 1, 2, 4+), a asserção falha e o Apidog sinaliza em vermelho, exibindo o corpo da resposta para debug imediato.

Passando dados entre requisições

O Apidog permite passar dados entre etapas com a sintaxe {{$.stepId.response.body.campo}}. Exemplo: extraia o message-id da resposta do envio e injete na requisição de verificação de status.

Testes automatizados via CI/CD

Quando estiver pronto para automatizar, integre o Apidog com GitHub Actions, GitLab CI ou Jenkins. Exporte seu cenário e rode via Apidog CLI a cada pull request, detectando regressões antes de chegar à produção.

Experimente grátis em apidog.com. Sem necessidade de cartão.

Conclusão

A API SMS da Vonage opera em esquema pay-as-you-go, sem mensalidade mínima. SMS de saída nos EUA: US$ 0,00809/mensagem; entrada: US$ 0,00649. Os custos variam conforme país, tipo de número e codificação. Recursos premium (Audit API, Auto-redação, suporte 24/7) aumentam o orçamento.

No comparativo, Telnyx e Plivo têm preços menores; Twilio lidera em ecossistema. Vonage é indicada para quem precisa de confiabilidade e alcance global via Ericsson.

Antes de ir para produção, use o Apidog para criar cenários de teste detalhados na integração Vonage. Valide fluxos, respostas e trate erros ainda em desenvolvimento — evite problemas na produção.

FAQ

Vonage é o mesmo que Nexmo?

Sim. A Vonage adquiriu a Nexmo em 2016. O portal de desenvolvedores segue em developer.vonage.com, e muitos endpoints ainda usam rest.nexmo.com. Ambas as marcas se referem ao mesmo produto.

A Vonage cobra mensalidade por SMS?

Não. Você paga por mensagem enviada/recebida e aluguel de número virtual. APIs complementares (Audit API, Auto-redação) têm mensalidade.

Quanto custa um número Vonage?

Números locais (10DLC) EUA iniciam em poucos dólares por mês. Toll-Free e short codes custam mais. Consulte o painel para preços atualizados.

Quais países a Vonage SMS suporta?

Mais de 190 países. As tarifas variam bastante. Baixe a planilha global no painel para detalhes completos.

A Vonage oferece desconto por volume?

Sim. Para grandes volumes, negocie com o time de vendas. Até fechar acordo, valem as tarifas padrão pay-as-you-go.

Posso receber SMS gratuitamente?

Números Toll-Free EUA geralmente recebem SMS de entrada sem custo. Código longo cobra US$ 0,00649/mensagem. Consulte tarifas por país na planilha.

Como Vonage e Twilio se comparam para SMS?

A Vonage tem tarifa ligeiramente maior que a Twilio nos EUA. Twilio lidera em ecossistema e integrações. Vonage se destaca pela confiabilidade e alcance global via Ericsson. Na prática, a escolha depende mais da experiência do desenvolvedor e suporte do que do preço por mensagem.

Cursor 3: O que significa para desenvolvedores de API?

Lucas — Fri, 03 Apr 2026 03:45:21 +0000

TL;DR: O Cursor 3 foi lançado em 2 de abril de 2026, substituindo a interface IDE-first por um workspace agent-first. Para desenvolvedores de API, as maiores mudanças são a execução paralela de agentes, saídas de ferramentas MCP mais ricas e uma transição da nuvem para o local que mantém seus fluxos de trabalho funcionando sem interrupção. Se você combinar o Cursor 3 com o MCP Server do Apidog, seus agentes de IA podem ler suas especificações de API ao vivo e gerar código preciso e consciente do esquema sem copiar e colar.

Experimente o Apidog hoje

A mudança que você provavelmente sentiu que estava por vir

Editores de código de IA vêm evoluindo rápido, mas o Cursor 3 não é só uma atualização incremental: é um redesenho completo do ambiente de desenvolvimento de IA.

Antes do Cursor 3, você atuava como usuário tradicional de IDE: abria arquivos, pedia ajuda a um agente, revisava as sugestões e seguia em frente. Agentes eram assistentes sob demanda.

O Cursor 3 muda a lógica: agentes passam a ser a unidade central de trabalho. Você gerencia vários agentes como abas no navegador, rodando em paralelo, monitorando saídas e promovendo as melhores soluções.

Para quem desenvolve API, isso é ainda mais importante: seu trabalho é altamente paralelo — endpoints, contratos, docs, rastreamento de schema, tudo acontecendo ao mesmo tempo. Agora, suas ferramentas acompanham esse ritmo.

💡 Nota: O Cursor 3 não conhece sua especificação de API sozinho. É aqui que entra o MCP Server do Apidog. Conecte uma vez, e os agentes do Cursor puxam seus schemas OpenAPI, definições de endpoint e cenários de teste direto do Apidog. Chega de agentes inventando nomes de campos: o código gerado já sai casando com sua spec.

Este artigo mostra o que mudou no Cursor 3, como isso impacta o seu fluxo de trabalho com APIs e um passo a passo para integrar Cursor 3 ao MCP Server do Apidog.

O que há de novo no Cursor 3

O Cursor 3 chegou com foco total em agentes. Veja os principais pontos para quem trabalha com API:

Agents Window

A Agents Window é a nova interface central. Execute agentes em múltiplos repositórios ao mesmo tempo, seja local, por worktree, na nuvem do Cursor, ou via SSH remoto.

Acesse via Cmd+Shift+P -> Agents Window. Dá para manter o IDE aberto ou alternar entre eles.

Na prática: Inicie um agente para criar um endpoint enquanto outro corrige bugs em uma lib compartilhada. Monitore ambos, intervenha ou aprove as diferenças quando necessário.

Modo Design

No Agents Window, o Modo Design permite anotar a interface do navegador visualmente. Selecione elementos, destaque áreas, adicione ao contexto do agente — sem precisar descrever “o botão no canto direito”.

Cmd+Shift+D para alternar
Shift+arrastar para selecionar área
Cmd+L para adicionar elemento ao chat

MCP Apps: saída de conteúdo estruturado

Agora, MCP Apps suportam saídas estruturadas, não só texto plano. Isso significa que respostas do MCP Server do Apidog (definições de endpoint, schemas, testes) chegam num formato que os agentes realmente entendem — sem precisar “interpretar” texto.

Worktrees, best-of-n e isolamento

Novos comandos:

/worktree: cria um git worktree isolado para experimentar sem riscos.
/best-of-n: executa a mesma tarefa em múltiplos modelos, cada um em seu próprio worktree, permitindo comparar abordagens (ex: Claude, GPT-4o, Gemini) e escolher o melhor resultado.

Transição da nuvem para o local

Os agentes transitam entre nuvem e máquina local. Comece uma tarefa longa na nuvem, puxe para local para testar, ou envie para a nuvem quando for fechar o laptop.

O que isso significa para o desenvolvimento de API

Desenvolver API sempre foi trabalho de multitarefa. Você alterna entre especificação, cliente (Apidog), editor, terminal, documentação. Cursor 3 começa a consolidar esse fluxo, tornando agentes persistentes e paralelos.

Desenvolvimento paralelo de endpoints

Construa múltiplos endpoints REST simultaneamente: atribua cada endpoint a um agente diferente, rode todos, revise as saídas e mescle os melhores. O tempo entre “preciso desses endpoints” e “tenho drafts para revisar” cai drasticamente.

Geração de código consciente do esquema

Sem acesso à especificação OpenAPI, agentes chutam nomes de campos e estruturas. Com o MCP Server do Apidog, o agente lê o schema real (ex: POST /orders exige customerId e items com productId/quantity). O código já sai alinhado, reduzindo correções.

Teste de contrato dentro do editor

Agentes do Cursor 3 podem executar comandos de terminal. Combine com a CLI do Apidog para validar contratos no próprio editor.

Exemplo:

Descreva o comportamento do endpoint.
O agente gera o código.
Ele executa apidog run --scenario ... contra o servidor mock.
Se o teste falhar, o agente itera até passar.

Documentação sempre sincronizada

Agentes do Cursor 3 leem a documentação do Apidog via MCP Server e detectam divergências entre código e spec. Configurando o fluxo corretamente, manter a doc atualizada vira parte do ciclo de revisão.

O que não mudou

O Cursor 3 não testa APIs automaticamente nem valida lógicas de autenticação ou rate limit. Ele é uma interface de agente, não uma plataforma de QA. Para saídas ricas no MCP, seu servidor MCP precisa suportar conteúdo estruturado (o do Apidog suporta).

Cursor 3 + Apidog MCP Server: fluxo de trabalho prático

Veja como usar juntos Cursor 3 e MCP Server do Apidog, em um fluxo de automação real.

Configuração

Conecte o MCP Server do Apidog ao Cursor. O server expõe endpoints, schemas, ambientes e cenários de teste como ferramentas MCP. Adicione nas configurações do Cursor:

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_access_token"
      }
    }
  }
}

O token de acesso você gera no Apidog, em Configurações da Conta > Token de Acesso à API. Assim, os agentes do Cursor acessam funções como get_endpoint_detail, list_endpoints e get_schema.

Workflow: criando um endpoint a partir da spec

Suponha que você adicionou o endpoint POST /invoices na sua spec Apidog, com request/response e cenário de teste. Para implementar:

Abra uma sessão de agente na Agents Window.
Descreva: > "Procure o endpoint POST /invoices no projeto Apidog. Leia seus schemas de request e response. Gere um handler Node.js/Express conforme a spec. Execute o cenário de teste para validar."

O agente:

Usa get_endpoint_detail via MCP para buscar a spec.
Gera o handler baseado no schema.
Executa apidog run --scenario invoice-creation-test --env staging.
Corrige o handler se o teste falhar.

Você só revisa e aprova a diferença. O código já nasce alinhado à spec real.

/best-of-n para endpoints complexos

Para lógica complexa, use /best-of-n: três agentes produzem implementações diferentes lendo a spec via MCP. Compare as soluções no worktree do Cursor, escolha a melhor abordagem.

Mantendo documentação sincronizada

Depois de subir o endpoint, peça ao agente:

"Verifique a doc do Apidog para POST /invoices. Compare com o código em invoices.js. Sinalize discrepâncias. Atualize a spec do Apidog se necessário."

O agente compara via MCP, propõe updates de spec ou código, e você aprova/rejeita. Divergência de doc vira parte do ciclo de revisão.

Veja mais em [visão geral do servidor apidog mcp] e [primeiros passos com a CLI do Apidog].

Configuração prática: primeiros passos

Passo 1: atualize o Cursor

Baixe a versão mais recente em cursor.com. Após instalar, abra a paleta (Cmd+Shift+P) e selecione "Agents Window" para garantir que está no Cursor 3.

Passo 2: gere um token de acesso Apidog

Faça login no Apidog. Em Configurações da Conta > Token de Acesso à API, gere um token com permissão de leitura para os projetos desejados.

Passo 3: adicione o Apidog MCP Server ao Cursor

Em Configurações do Cursor > MCP, adicione:

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_token_here",
        "APIDOG_PROJECT_ID": "your_project_id"
      }
    }
  }
}

O ID do projeto aparece na URL do Apidog ao abrir o projeto. Salve e reinicie o Cursor.

Passo 4: verifique a conexão

Abra a Agents Window e inicie uma nova sessão. Digite: "Liste os endpoints no meu projeto Apidog." Se o agente retornar os endpoints, está tudo certo.

Passo 5: instale e configure a CLI do Apidog

Para rodar testes automatizados, instale a CLI:

npm install -g apidog-cli

Verifique com apidog -v. No Apidog, acesse um cenário de teste e a aba CI/CD. Copie o comando CLI já preenchido (com credenciais e ID de cenário). Execute pelo terminal integrado do Cursor ou peça para um agente rodar como parte do fluxo.

Passo 6: execute sua primeira tarefa de agente com MCP

Na Agents Window, peça:

"Procure o schema do objeto User no Apidog. Gere uma interface TypeScript que corresponda exatamente."

Compare a saída com seu schema real. Se estiver correta, integração concluída! Agora você pode criar fluxos mais avançados de leitura de spec, geração de código e execução de testes — tudo em uma sessão de agente.

Conclusão

O Cursor 3 muda a forma de trabalhar com IA no desenvolvimento: sai o foco em editor, entra o foco em agentes — ideal para automação de APIs e trabalho paralelo. A saída estruturada do MCP, pouco destacada no changelog, é um dos recursos mais úteis para quem trabalha com API: agentes recebem dados tipados e precisos, o código gerado precisa de menos ajustes.

Integrando Cursor 3 com MCP Server e CLI do Apidog, você monta um pipeline em que o agente realmente entende sua API: lê a spec, gera código alinhado, executa cenários de teste. Não é demonstração, é workflow utilizável no dia a dia.

Perguntas frequentes

O Cursor 3 substitui a interface IDE existente?

Não. O Cursor 3 adiciona a Agents Window, mas o IDE continua disponível. Use ambos como preferir.

Qual a diferença entre o Cursor 3 e a versão anterior?

A arquitetura: agora o foco são os agentes, não o editor. Agents Window, execução paralela, transição nuvem-local, Modo Design e comandos /worktree e /best-of-n são as principais novidades.

Como o MCP Server do Apidog se conecta ao Cursor 3?

Adicione o MCP Server nas configurações do Cursor. O server expõe as specs do projeto Apidog como ferramentas MCP. Agentes usam essas ferramentas para ler endpoints, schemas e cenários sem cópia manual. O suporte a conteúdo estruturado garante dados tipados, não só texto.

Agentes do Cursor 3 podem executar cenários de teste do Apidog automaticamente?

Sim, via CLI do Apidog. Os agentes podem rodar comandos de terminal, executar cenários de teste, analisar saídas e ajustar o código conforme os resultados.

Preciso de plano pago do Cursor para usar Agents Window?

Agents Window está disponível em todos os planos. Execução de agentes na nuvem exige assinatura, mas execução local funciona no plano gratuito. Confira cursor.com/pricing para detalhes atualizados.

Como Executar Gemma 4 Localmente com Ollama: Guia Completo

Lucas — Fri, 03 Apr 2026 02:50:16 +0000

Resumo

Gemma 4 foi lançado em 3 de abril de 2026, e o Ollama v0.20.0 adicionou suporte no mesmo dia. Você pode baixar e executar o modelo padrão gemma4:e4b em apenas dois comandos. Este guia apresenta todos os passos práticos para configurar, escolher variantes, usar a API e testar endpoints locais do Gemma 4 com o Apidog.

Experimente o Apidog hoje

Introdução

Google lançou o Gemma 4 em 2 de abril de 2026. Em 24 horas, o Ollama lançou a v0.20.0 com suporte a todas as quatro variantes do modelo.

Para desenvolvedores, isso é uma grande mudança: o Gemma 4 salta de 20,8% (Gemma 3) para 89,2% no AIME 2026, e de 110 para 2150 ELO no Codeforces. Ele oferece chamada de função nativa, modos de raciocínio configuráveis, contexto de 256K em variantes maiores — tudo rodando localmente.

Se você está criando aplicações API-first, rodar o Gemma 4 localmente oferece uma camada de IA rápida e privada para gerar dados de mock, escrever cenários de teste e validar respostas sem expor dados a servidores remotos.

💡 Dica: Com o Gemma 4 rodando localmente, o Smart Mock do Apidog gera dados realistas para respostas de API usando inferência baseada em IA. Basta definir o schema da API e o Apidog gera mocks compatíveis — útil para testes consistentes sem fixtures manuais.

Este guia cobre da instalação à sua primeira chamada de API local.

O que há de novo no Gemma 4

Gemma 4 vem em quatro variantes, cada uma com capacidades distintas.

Principais novidades:

Raciocínio e codificação: O modelo 31B atinge 80% no LiveCodeBench v6 (vs. 29,1% do 27B anterior).
Mixture-of-Experts (MoE): A variante 26B usa apenas 4B de parâmetros ativos por inferência, entregando ótima qualidade com menor custo computacional.
Contexto longo: Modelos E2B/E4B suportam 128K tokens; 26B/31B suportam 256K.
Chamada de função nativa: Todos os modelos aceitam schemas de função e retornam JSON válido.
Entrada multimodal: E2B/E4B aceitam áudio e imagem.
Modos de raciocínio: Ative/desative chain-of-thought por requisição.

Variantes do modelo Gemma 4 explicadas

Escolha o modelo certo para seu hardware:

Modelo	Tamanho em disco	Contexto	Arquitetura	Melhor para
`gemma4:e2b`	7.2 GB	128K	Densa	Laptops, edge, áudio/imagem
`gemma4:e4b`	9.6 GB	128K	Densa	Maioria dos desenvolvedores
`gemma4:26b`	18 GB	256K	MoE (4B)	Qualidade por GB
`gemma4:31b`	20 GB	256K	Densa	Máxima qualidade

e4b é o modelo padrão ao rodar ollama run gemma4. Cabe em GPUs com 10+ GB de VRAM ou memória unificada do Apple Silicon.

O 26b (MoE) vale testar se você tem 20+ GB de RAM: qualidade próxima a modelos grandes com desempenho de 4B.

Pré-requisitos

Ollama v0.20.0 ou superior

Verifique:

  ollama --version

Atualize se necessário:

  # macOS
  brew upgrade ollama

  # Linux
  curl -fsSL https://ollama.com/install.sh | sh

No Windows, baixe de ollama.com.

Hardware mínimo:
- gemma4:e2b: 8 GB RAM (16 GB recomendado)
- gemma4:e4b: 10 GB VRAM ou 16 GB unificada
- gemma4:26b: 20+ GB RAM/unificada
- gemma4:31b: 24 GB VRAM ou 32 GB unificada

Instalando e executando o Gemma 4

Execute o modelo padrão:

ollama run gemma4

Na primeira execução, ~9,6 GB serão baixados. Você entra em uma shell interativa:

>>> Quais são os códigos de status HTTP para erros de cliente?

Para variantes específicas:

# Modelo edge, menor
ollama run gemma4:e2b

# Modelo MoE
ollama run gemma4:26b

# Flagship
ollama run gemma4:31b

Para baixar sem rodar:

ollama pull gemma4
ollama pull gemma4:26b

Liste modelos baixados:

ollama list

Usando a API Gemma 4 localmente

Ollama expõe uma API REST em http://localhost:11434.

Gerar uma conclusão

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Escreva uma resposta JSON para um endpoint de API de perfil de usuário",
    "stream": false
  }'

Chat (endpoint OpenAI)

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "Gere um mock JSON realista para uma resposta de API de pedido de e-commerce"
      }
    ]
  }'

Cliente Python (requests)

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("Liste os campos que uma resposta de API de pagamento deve incluir")
print(result)

Usando o SDK Python do OpenAI

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # requerido pelo SDK
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "Você gera dados de resposta de API realistas em formato JSON."
        },
        {
            "role": "user",
            "content": "Gere uma resposta de exemplo para um endpoint GET /users/{id}"
        }
    ]
)

print(response.choices[0].message.content)

Usando chamada de função com o Gemma 4

Gemma 4 suporta chamada de função nativa. Defina um schema e o modelo retornará JSON validado.

Exemplo:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "Recuperar um usuário por ID da API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "O ID de usuário único"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "Se deve incluir o histórico de pedidos"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "Obter usuário 42 com seu histórico de pedidos"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

Ativando o modo de raciocínio

Para tarefas complexas (ex: testes, análise de specs), ative o raciocínio chain-of-thought:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "Projetar um cenário de teste completo para uma API de processamento de pagamentos com casos extremos"
        }
    ],
    extra_body={"think": True}
)

print(response.choices[0].message.content)

Para prompts simples, desative para ganhar desempenho.

Testando respostas da API Gemma 4 com Apidog

Com o Gemma 4 rodando, teste seus endpoints via Apidog:

Passos práticos:

Importe a especificação da API do Ollama
- No Apidog, crie projeto e use a base http://localhost:11434.
Defina endpoints
- POST /api/generate (resposta única)
- POST /v1/chat/completions (chat multi-turno)
- GET /api/tags (listar modelos)
Configure Cenário de Teste
- Passo 1: GET /api/tags — afirme que gemma4 está na lista.
- Passo 2: POST /api/generate — afirme que response não está vazio.
- Passo 3: POST /v1/chat/completions — valide formato da resposta.

Use o processador "Extrair Variável" para passar respostas entre passos e simular conversas multi-turno.

Valide esquemas de resposta
- Ative o Teste de Contrato do Apidog para garantir aderência ao OpenAPI.
Smart Mock para dev paralelo
- Gere respostas mock automáticas e compatíveis com o schema, sem precisar do modelo local rodando.

Entrada multimodal com o Gemma 4

E2B/E4B aceitam imagens (base64) junto ao texto:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Descreva o fluxo da API mostrado neste diagrama e identifique possíveis caminhos de erro"
                }
            ]
        }
    ]
)

Use para analisar diagramas de arquitetura, capturas de documentação ou extrair dados de imagens.

Problemas comuns e soluções

Modelo não encontrado: Rode ollama pull gemma4 ou cheque com ollama list.
Inferência lenta na CPU: Use gemma4:e2b para melhor desempenho.
Erros de memória: Veja VRAM/memória com ollama ps. Se necessário, troque para modelo menor.
Apple Silicon não carrega: Atualize Ollama (v0.20.0+).
Porta 11434 ocupada: Use porta customizada: OLLAMA_HOST=0.0.0.0:11435 ollama serve
Respostas cortadas: Aumente contexto com "options": {"num_ctx": 8192} no corpo JSON.

Gemma 4 vs outros modelos locais

Modelo	Melhor tamanho	Contexto	Chamada de função	Codificação (benchmark)
Gemma 4	e4b (9.6 GB)	128K-256K	Nativa	80% LiveCodeBench
Llama 3.3	70B-Q4 (40 GB)	128K	Nativa	~60% LiveCodeBench
Qwen3.6-Plus	72B-Q4 (44 GB)	128K	Nativa	Forte
Mistral Small	24B (14 GB)	128K	Nativa	Moderado

Destaque: O Gemma 4 26B MoE (18 GB) entrega tokens/s superiores aos modelos densos grandes, mantendo ótima qualidade.

Para codificação, o 31B é competitivo com modelos maiores. Para edge/laptops, use o e2b (<8 GB).

Conclusão

Gemma 4 com Ollama entrega uma das melhores experiências locais para desenvolvedores hoje. Instalação rápida, roda na maioria das máquinas, e qualidade de raciocínio/codificação muito superior ao Gemma 3.

Comece com ollama run gemma4, teste a API com Apidog para validar endpoints, e escolha a variante ideal conforme sua carga de trabalho.

Se sua equipe constrói features de API sobre o Gemma 4, combine inferência local com Smart Mock e Cenários de Teste do Apidog para um fluxo completo de desenvolvimento sem dependências remotas.

Perguntas Frequentes

Como atualizo o Gemma 4 no Ollama?

Rode ollama pull gemma4 — baixa só o que mudou.

Posso rodar o Gemma 4 sem GPU?

Sim, mas é lento (1-3 tokens/s). Use e2b para CPUs.

Qual a diferença entre gemma4:e2b e gemma4:e4b?

Ambos são densos para edge. E4B é maior e lida melhor com prompts complexos. E2B é menor e aceita áudio. Para texto, e4b é padrão.

Funciona com LangChain e LlamaIndex?

Sim. Configure o provider Ollama para http://localhost:11434 e use gemma4 como modelo.

A API local é compatível com código OpenAI?

Quase sempre. Só mude o base_url para http://localhost:11434/v1 e forneça qualquer api_key.

Como uso o modo de raciocínio?

Adicione "think": true no extra_body (SDK OpenAI) ou no JSON direto. Desative para tarefas simples.

Posso servir Gemma 4 para outras máquinas?

Sim. Use OLLAMA_HOST=0.0.0.0:11434 ollama serve e acesse pelo IP da máquina.

Qual o melhor modelo Gemma 4 para dev de API?

Para mocks e testes, e4b equilibra velocidade e qualidade. Para análise complexa, 26b entrega melhor custo-benefício.

Como Executar Gemma 4 como Backend de API

Lucas — Fri, 03 Apr 2026 02:37:01 +0000

TL;DR:

O Google lançou o Gemma 4 em abril de 2026: uma família de quatro modelos abertos sob licença Apache 2.0 que supera modelos 20x maiores em benchmarks padrão. Você pode utilizar a API do Gemma 4 via Google AI Studio, Vertex AI ou rodar localmente com Ollama e vLLM. Combine com o Smart Mock do Apidog para gerar respostas de API realistas automaticamente a partir dos seus esquemas OpenAPI, sem escrever regras de mock.

Experimente o Apidog hoje

Introdução

A maioria dos modelos de IA de código aberto força você a escolher entre potência e facilidade de implantação: ou um modelo enorme que não roda no seu laptop, ou algo pequeno que não aguenta raciocínio multi-etapa. O Gemma 4 elimina essa escolha.

O Gemma 4 é a linha mais avançada de modelos abertos do Google DeepMind. O modelo 31B Dense está em 3º lugar entre modelos abertos no Arena AI, superando concorrentes 20x maiores. O 26B MoE está em 6º, ambos rodando em uma única GPU de 80GB. Os modelos leves E2B e E4B rodam offline em dispositivos móveis.

Para desenvolvedores de API, o Gemma 4 é especialmente relevante: suporta chamada de função nativa, saída JSON estruturada e contexto de até 256K tokens. Isso o torna ideal para automação de testes de API, mocks e análise de respostas.

💡 Se você está usando o Gemma 4 e precisa validar respostas geradas por IA contra sua especificação OpenAPI, o Smart Mock do Apidog gera respostas mock conformes ao esquema da definição de API automaticamente. Sem regras manuais: ele lê seu esquema e produz dados contextuais instantaneamente. Baixe o Apidog e integre ao seu fluxo de API Gemma 4.

O que é o Gemma 4 e o que mudou

Gemma 4 é a quarta geração de modelos de linguagem abertos do Google DeepMind. O nome vem do latim para “pedra preciosa”. Desde 2024, foram mais de 400 milhões de downloads e 100.000 variantes criadas pela comunidade – o chamado “Gemmaverse”.

O Gemma 4 é lançado sob licença Apache 2.0, diferente das versões anteriores, permitindo uso, modificação e distribuição comercial sem restrições – ótimo para empresas que precisam de controle total.

O maior diferencial do Gemma 4 é a “inteligência por parâmetro”: o 31B Dense entrega desempenho de ponta a uma fração do custo de modelos como GPT-4 ou Claude 3 Sonnet. No Arena AI (abril/2026), o Gemma 4 31B supera modelos de até 600B parâmetros.

Principais novidades em relação ao Gemma 3:

Entrada multimodal nativa: processa imagens e vídeos, modelos edge (E2B/E4B) também áudio. Não disponível no Gemma 3.
Janelas de contexto maiores: E2B/E4B suportam 128K tokens, 26B/31B vão até 256K tokens – suficiente para um repositório inteiro num prompt.
Suporte a fluxo agêntico: chamada de função nativa, saída JSON estruturada, instruções de sistema – perfeito para agentes que orquestram APIs.
Raciocínio avançado: grandes ganhos em matemática e instruções multi-etapa vs. Gemma 3 – útil para gerar testes de API.
140+ idiomas nativamente: treinado em múltiplos idiomas, pronto para produtos globais.
Licenciamento Apache 2.0: uso comercial sem ambiguidade.

Variantes e capacidades do Gemma 4

O Google lançou o Gemma 4 em quatro tamanhos, cada um otimizado para um tipo de hardware:

Modelo	Parâmetros	Parâmetros ativos	Contexto	Melhor para
E2B	2B efetivos	~2B	128K	Mobile, IoT, borda offline
E4B	4B efetivos	~4B	128K	Celulares, Raspberry Pi, Jetson Orin
26B MoE	26B total	~3.8B ativos	256K	Backend sensível a latência
31B Dense	31B	31B	256K	Qualidade máxima, pesquisa, fine-tuning

Os modelos E2B/E4B são Mixture of Experts, ativando só parte dos parâmetros por token. Isso economiza bateria e RAM em dispositivos limitados, rodando totalmente offline no Android via AICore Developer Preview.

O 26B MoE ativa apenas 3.8B parâmetros na inferência, sendo rápido para backends. O 31B Dense é para máxima qualidade e domínio específico. Todos suportam ajuste por instrução (IT) e base.

Para API, prefira o 26B MoE (equilíbrio velocidade/qualidade) ou 31B Dense (quando precisa de JSON estruturado ou lógica complexa).

Todos suportam chamada de função e saída JSON – essenciais para automação de API.

Como configurar a API do Gemma 4: passo a passo

Você pode usar o Gemma 4 via Google AI Studio (mais rápido), Vertex AI (empresarial) ou localmente (Ollama/vLLM). Veja como fazer em cada um:

Opção 1: Google AI Studio (prototipagem rápida)

Acesse Google AI Studio e crie uma conta gratuita.
Gere sua chave de API.

Instale o SDK:

pip install google-genai

Primeira chamada:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemma-4-31b-it")

response = model.generate_content(
    "Generate a JSON object for a user account with id, email, and created_at fields."
)

print(response.text)

Saída JSON estruturada:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = """
Generate 3 sample user objects for an e-commerce API. 
Each user should have: id (integer), email (string), username (string), 
created_at (ISO 8601 timestamp), and subscription_tier (free|pro|enterprise).
Return as a JSON array.
"""

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

Opção 2: Implantação local com Ollama

Instale o Ollama em ollama.com.
Baixe o modelo:

ollama pull gemma4

Rode o servidor:

ollama serve

Faça uma chamada compatível com a API OpenAI:

import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "Generate a valid JSON response for a REST API /products endpoint. Include id, name, price, and stock fields."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

Opção 3: Chamada de função nativa (orquestração de API)

Use chamada de função nativa para definir ferramentas que o modelo pode acionar:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "Retrieve the OpenAPI schema for a given endpoint path",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "The API endpoint path, e.g. /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)

response = model.generate_content(
    "I need to test the GET /users/{id} endpoint. What schema should the response follow?"
)

if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"Model called function: {fc.name}")
    print(f"With args: {dict(fc.args)}")

Esse padrão é base para pipelines de teste de API agênticos.

Gerando mocks de API com IA (Gemma 4)

Para prototipar frontends ou testar casos edge, gere dados mock realistas via Gemma 4 a partir do seu schema OpenAPI:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
Generate 5 realistic mock responses for an order management API.
Each response must conform exactly to this JSON Schema:
{json.dumps(schema, indent=2)}

Make the data realistic: use realistic prices, product IDs, and varied statuses.
Return as a JSON array of 5 order objects.
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))

O Gemma 4 entende restrições do JSON Schema (enum, pattern, range), então entrega mocks compatíveis com seu contrato de API – não apenas dados aleatórios.

Você pode aplicar esse padrão para qualquer endpoint: forneça o schema OpenAPI e obtenha dados de teste prontos.

Para mocks avançados, combine com lógica condicional no prompt. Com contexto de 256K tokens, você pode passar toda a especificação OpenAPI para gerar mocks para múltiplos endpoints de uma vez.

Dica prática:

Exporte sua coleção do Apidog como OpenAPI, cole no prompt e peça para o Gemma 4 gerar 10 casos de teste por endpoint – você terá um dataset mock completo em segundos.

Testando respostas do Gemma 4 com Apidog

Depois de gerar dados ou integrar o Gemma 4 ao seu pipeline de API, valide as respostas contra o schema com o recurso Test Scenarios do Apidog.

Workflow recomendado:

Passo 1: Importe seu endpoint Gemma 4 no Apidog.

No projeto, crie um endpoint com a URL do wrapper Gemma 4 (ou direto do Google AI Studio). Defina o schema de resposta esperado.

Passo 2: Use Smart Mock para gerar respostas base.

O Smart Mock do Apidog gera exemplos realistas via nome e tipo dos campos. email recebe e-mail válido, created_at um timestamp, etc.

O Smart Mock prioriza: campos mock customizados > nome de propriedade > padrão do JSON Schema. Você pode sobrescrever campos e deixar o resto para o motor.

Passo 3: Crie um Cenário de Teste para a pipeline Gemma 4.

No módulo Testes, crie um cenário, adicione chamada ao Gemma 4 e passos de asserção.

Exemplo de fluxo:

Chame endpoint de autenticação
Envie prompt ao Gemma 4 com o token
Extraia JSON do corpo de resposta
Valide o JSON contra o schema
Encaminhe os dados para outro endpoint POST

Passo 4: Configure as asserções.

Valide status code, headers e campos JSON. Com o Gemma 4, geralmente assert que candidates[0].content.parts[0].text existe e corresponde ao schema.

Use o Extract Variable do Apidog para puxar a saída do Gemma 4 para variáveis, usando em requisições subsequentes.

Passo 5: Execute com testes orientados a dados.

O Apidog suporta CSV e JSON com prompts variados. Importe 50 variações e rode todos os cenários com um clique – ideal para testar robustez frente a diferentes entradas.

O fluxo completo (do schema ao teste automatizado) leva cerca de 15 minutos para configurar. Depois, execute via Apidog CLI em seu CI/CD.

Casos de uso práticos

Geração de dados de teste de API:

Com modo JSON do Gemma 4 + seu schema OpenAPI, gere centenas de registros realistas em minutos. Peça para cobrir casos edge e deixe o modelo gerar.
Mock inteligente de API:

Ao invés de mocks estáticos, retorne respostas contextuais. Um mock de busca retorna produtos diferentes dependendo da query, sem codificar manualmente cada caso.
Geração de documentação de API:

Alimente o codebase inteiro (contexto 256K) e peça ao Gemma 4 para gerar docs OpenAPI de endpoints não documentados. Use chamada de função para um agente que lê rotas e escreve specs.
Validação de schema de resposta:

Ao consumir APIs de terceiros, valide se as respostas batem com o esperado. O Gemma 4 pode analisar e identificar campos ausentes, tipos errados, enums inválidos – melhor que validadores de JSON Schema básicos.
Geração automatizada de testes de regressão:

Dê ao Gemma 4 sua spec de API + bugs conhecidos e peça para ele escrever casos de teste que teriam capturado cada bug, incluindo relações complexas de schema.

Gemma 4 vs. outros modelos abertos para API

Modelo	Parâmetros	Contexto	Saída JSON	Chamada de função	Licença
Gemma 4 31B	31B	256K	Nativa	Nativa	Apache 2.0
Gemma 4 26B MoE	26B (3.8B ativos)	256K	Nativa	Nativa	Apache 2.0
Llama 3.3 70B	70B	128K	Via prompt	Via prompt	Llama Community
Mistral 7B	7B	32K	Via prompt	Limitada	Apache 2.0
Qwen 2.5 72B	72B	128K	Nativa	Nativa	Apache 2.0

Para API, foque em: saída JSON nativa, chamada de função e tamanho de contexto. Gemma 4 31B/26B entregam tudo.

O Llama 3.3 70B é o principal concorrente, mas consome o dobro de GPU e fica atrás no ranking Arena AI. O Mistral 7B é rápido mas limitado em contexto/funções. Qwen 2.5 72B é forte, especialmente para multilinguismo, mas exige hardware pesado.

A licença Apache 2.0 do Gemma 4 é diferencial: ao contrário da Llama Community License, não tem restrições comerciais.

Recomendação:

Para desenvolvimento de API: use o Gemma 4 26B MoE (latência baixa) ou 31B (qualidade máxima).

Conclusão

O Gemma 4 é uma alternativa aberta robusta a APIs proprietárias de IA para automação de API. A licença Apache 2.0 simplifica o uso comercial. Chamada de função e saída JSON nativas facilitam integração sem engenharia de prompt.

Com quatro tamanhos, cobre de mobile a estações de trabalho. O 26B MoE é a opção ideal para a maioria dos devs de API: qualidade quase de ponta, custo de inferência baixo.

Combine Gemma 4 e Apidog para fechar o ciclo: gere dados, prototipe mocks e valide tudo com cenários de teste automatizados.

FAQ

O que é o Gemma 4?

O Gemma 4 é a última geração de modelos de linguagem abertos do Google DeepMind, lançada em abril de 2026, disponível em quatro tamanhos (E2B, E4B, 26B MoE, 31B Dense) sob Apache 2.0. O 31B está em 3º lugar no Arena AI.

O Gemma 4 é gratuito?

Os pesos são gratuitos sob Apache 2.0. Você paga apenas pela infraestrutura de computação que usar. No Google AI Studio há camada gratuita com limites. Vertex AI cobra conforme o uso de cloud.

O Gemma 4 gera JSON estruturado?

Sim, via parâmetro response_mime_type: "application/json" no SDK Google Generative AI – retorna JSON válido sempre, essencial para integração programática.

Como o Gemma 4 se compara ao GPT-4o para APIs?

GPT-4o é proprietário, sem opção local e mais caro. O Gemma 4 31B é gratuito localmente e competitivo em benchmarks de raciocínio. Para times que precisam de privacidade ou controle de custo, avalie o Gemma 4.

Posso fazer fine-tuning do Gemma 4?

Sim, via Google AI Studio, Vertex AI e ferramentas como Hugging Face TRL. Fine-tuning em schemas e padrões de resposta pode melhorar a qualidade para casos específicos.

Que hardware roda o Gemma 4 localmente?

31B e 26B cabem em uma NVIDIA H100 80GB bfloat16. Versões quantizadas rodam em GPUs com 16-24GB VRAM. E4B/E2B rodam em smartphones, Raspberry Pi, Jetson, etc.

O Gemma 4 suporta chamada de função?

Sim, todos suportam chamada de função nativa. Defina ferramentas como objetos JSON, o modelo chama conforme necessário, passando argumentos estruturados.

Como testar respostas do Gemma 4 automaticamente?

Use os Cenários de Teste do Apidog: importe seu endpoint, configure as etapas e asserções, e rode local ou no CI/CD a cada push.

Links úteis:

API Qwen3.6-Plus: Desempenho Superior ao Claude em Testes de Terminal

Lucas — Thu, 02 Apr 2026 09:29:59 +0000

TL;DR

Qwen3.6-Plus foi lançado oficialmente. Ele atinge 78,8% no SWE-bench Verified e 61,6% no Terminal-Bench 2.0, superando o Claude Opus 4.5 nesse benchmark. Possui janela de contexto de 1M de tokens, novo parâmetro preserve_thinking para loops de agente e integração direta com Claude Code, OpenClaw e Qwen Code via API compatível com OpenAI.

Experimente o Apidog hoje

Da prévia ao lançamento

Se você acompanhou nosso guia anterior sobre o Qwen 3.6 Plus Preview no OpenRouter, já conhece o potencial do modelo. A prévia foi lançada em 30 de março, sem lista de espera e com acesso gratuito via OpenRouter. Nos dois primeiros dias, processou mais de 400 milhões de tokens em 400.000 requisições.

Agora, o lançamento oficial traz a versão de produção: API estável, SLA garantido e o novo parâmetro de API para agentes multi-etapas.

Este guia explica o que mudou, como integrar com a API e como validar tudo no Apidog antes do deploy.

O que é Qwen3.6-Plus

Qwen3.6-Plus é um modelo MoE (mixture of experts) hospedado pela equipe Qwen da Alibaba. Utiliza ativação esparsa, ativando apenas parte dos parâmetros por token, garantindo desempenho forte com menor custo computacional.

Principais especificações:

Janela de contexto: 1 milhão de tokens
Raciocínio em cadeia de pensamento (CoT) obrigatório
Novo parâmetro preserve_thinking para agentes
Suporte multimodal: visão, vídeo, documentos
API compatível com OpenAI, Anthropic e OpenAI Responses

Versões menores open source serão lançadas em breve. Se você precisa dos pesos, fique atento.

Resultados dos benchmarks

Agentes de codificação

Qwen3.6-Plus fica um pouco atrás do Claude Opus 4.5 no SWE-bench, mas lidera nas operações de terminal.

No Terminal-Bench 2.0 (operações reais de shell, múltiplas etapas, 3h de timeout, 32 CPUs), Qwen3.6-Plus faz 61,6% vs 59,3% do Claude Opus 4.5 — diferença relevante para automação de terminal.

Agentes gerais e uso de ferramentas

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
TAU3-Bench	70.2%	70.7%
DeepPlanning	33.9%	41.5%
MCPMark	42.3%	48.2%
MCP-Atlas	71.8%	74.1%
WideSearch	76.4%	74.3%

Destaque para o MCPMark (integrações GitHub MCP) e DeepPlanning (tarefas de planejamento de longo prazo).

Raciocínio e conhecimento

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
GPQA	87.0%	90.4%
LiveCodeBench v6	84.8%	87.1%
IFEval strict	90.9%	94.3%
MMLU-Pro	89.5%	88.5%

GPQA e IFEval são importantes para tarefas de raciocínio e instruções complexas.

Multimodal

Qwen3.6-Plus é nativamente multimodal e lidera benchmarks de documentos, espaciais e contagem.

Benchmark	Qwen3.6-Plus	Notas
OmniDocBench 1.5	91.2%	Líder na tabela
RefCOCO avg	93.5%	Líder na tabela
We-Math	89.0%	Líder na tabela
CountBench	97.6%	Líder na tabela
OSWorld-Verified	62.5%	Atrás de Claude (66,3%)

Em tarefas de compreensão de documentos e ancoragem espacial, Qwen3.6-Plus se destaca.

Como chamar a API

O Qwen3.6-Plus está disponível no Alibaba Cloud Model Studio. Pegue sua chave em modelstudio.alibabacloud.com.

URLs regionais:

Singapura: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
Pequim: https://dashscope.aliyuncs.com/compatible-mode/v1
Virgínia (EUA): https://dashscope-us.aliyuncs.com/compatible-mode/v1

Chamada básica com streaming

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=[{"role": "user", "content": "Review this Python function and find bugs."}],
    extra_body={"enable_thinking": True},
    stream=True
)

reasoning = ""
answer = ""
is_answering = False

for chunk in completion:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        if not is_answering:
            reasoning += delta.reasoning_content
    if delta.content:
        if not is_answering:
            is_answering = True
        answer += delta.content
        print(delta.content, end="", flush=True)

O parâmetro `preserve_thinking`

Na prévia, só o raciocínio atual era mantido. Agora, com preserve_thinking: true, o modelo retém toda a cadeia de pensamento da conversa — recomendado para loops de agente multi-etapas.

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=conversation_history,
    extra_body={
        "enable_thinking": True,
        "preserve_thinking": True, # mantém toda a cadeia de raciocínio
    },
    stream=True
)

Use Qwen3.6-Plus com Claude Code

A API Qwen é compatível com o protocolo Anthropic. Basta ajustar as variáveis de ambiente para usar com Claude Code:

npm install -g @anthropic-ai/claude-code

export ANTHROPIC_MODEL="qwen3.6-plus"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.6-plus"
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your_dashscope_api_key

claude

Use Qwen3.6-Plus com OpenClaw

OpenClaw é um agente de codificação open source auto-hospedado. Instale e aponte para o Model Studio:

# Instalar (Node.js 22+)
curl -fsSL https://molt.bot/install.sh | bash

export DASHSCOPE_API_KEY=your_key
openclaw dashboard

Edite ~/.openclaw/openclaw.json e adicione:

{
  "models": {
    "providers": [{
      "name": "alibaba-coding-plan",
      "baseUrl": "https://coding-intl.dashscope.aliyuncs.com/v1",
      "apiKey": "${DASHSCOPE_API_KEY}",
      "models": [{"id": "qwen3.6-plus", "reasoning": true}]
    }]
  },
  "agents": {
    "defaults": {"models": ["qwen3.6-plus"]}
  }
}

Use Qwen3.6-Plus com Qwen Code

Qwen Code é o agente de terminal open source da Alibaba, com 1.000 chamadas de API gratuitas por dia via OAuth.

npm install -g @qwen-code/qwen-code@latest
qwen
# Digite /auth para ativar o nível gratuito

Por que `preserve_thinking` muda o comportamento do agente

A maioria das APIs LLM descarta o raciocínio de etapas anteriores. Em agentes multi-turn, isso gera inconsistência: o modelo não lembra por que tomou decisões passadas.

Com preserve_thinking, toda a cadeia de raciocínio é mantida — essencial para tarefas complexas de múltiplas etapas.

conversation = []

def agent_step(user_message, preserve=True):
    conversation.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="qwen3.6-plus",
        messages=conversation,
        extra_body={
            "enable_thinking": True,
            "preserve_thinking": preserve,
        },
        stream=False
    )

    message = response.choices[0].message
    conversation.append({"role": "assistant", "content": message.content})
    return message.content

# Exemplo: agente de revisão de código multi-etapas
result = agent_step("Analyze the auth module for security issues.")
result = agent_step("Now suggest fixes for the top 3 issues you found.")
result = agent_step("Write tests that validate each fix.")

Sem preserve_thinking, o modelo perde o histórico da análise. Com ele, a consistência aumenta e o raciocínio é compartilhado entre etapas.

Para que é melhor

Correção de bugs em nível de repositório: SWE-bench Verified (78,8%) e SWE-bench Pro (56,6%) são altamente competitivos.
Automação de terminal: Liderança no Terminal-Bench 2.0 para fluxos shell intensivos.
Chamada de ferramentas MCP: Liderança no MCPMark (48,2%).
Análise de documentos longos: Janela de 1M tokens, excelente para revisões extensas.
Geração de código frontend: Empate técnico com Claude Opus 4.5 no QwenWebBench.
Multilíngue: WMT24++ (84,3%) e MAXIFE (88,2%) mostram força em vários idiomas.

Testando chamadas de API do Qwen3.6-Plus com Apidog

O endpoint é compatível com OpenAI. Importe para o Apidog e teste como qualquer API.

Configure uma requisição POST para https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions e adicione sua chave de API como variável de ambiente: Authorization: Bearer {{DASHSCOPE_API_KEY}}.

Asserções de resposta:

pm.test("Response contains choices", () => {
  const body = pm.response.json();
  pm.expect(body).to.have.property("choices");
  pm.expect(body.choices[0].message.content).to.be.a("string").and.not.empty;
});

pm.test("No empty reasoning when thinking enabled", () => {
  const choice = pm.response.json().choices[0];
  if (choice.message.reasoning_content !== undefined) {
    pm.expect(choice.message.reasoning_content).to.not.be.empty;
  }
});

Use o Smart Mock do Apidog para simular respostas durante o desenvolvimento — economize tokens e agilize testes.

Para agentes multi-turn, crie Cenários de Teste encadeando múltiplas requisições e valide que o preserve_thinking mantém o raciocínio entre etapas.

Baixe o Apidog gratuitamente para configurar esses testes.

O que vem a seguir

A equipe Qwen vai lançar variantes menores open source nos próximos dias — modelos MoE esparsos com pesos Apache 2.0.

No roadmap:

Tarefas de repositório com horizontes mais longos e múltiplos arquivos
Agentes multimodais mais avançados (GUI, codificação visual nativa)

Se seguir o padrão do Qwen3.5, essas variantes open source devem se tornar padrão para agentes de codificação auto-hospedados rapidamente.

Conclusão

O Qwen3.6-Plus fecha a distância com Claude Opus 4.5 em codificação e lidera em operações de terminal, MCP e planejamento. Janela de 1M de tokens, protocolo Anthropic e preserve_thinking tornam-no prático para agentes de produção.

O período de prévia no OpenRouter foi útil para testes. A API oficial garante estabilidade, SLA e recursos avançados para fluxos multi-turn.

O Apidog cuida dos testes: importe o endpoint OpenAI, escreva asserções, use mock, valide respostas e rode testes de regressão sempre que atualizar modelo ou API.

FAQ

Qual a diferença entre Qwen3.6-Plus e a prévia?

A prévia (qwen/qwen3.6-plus-preview) saiu no OpenRouter em 30 de março de 2026. O lançamento oficial adiciona o parâmetro preserve_thinking, SLA garantido e suporte ao Model Studio. Variantes menores open source estão a caminho.

O que é preserve_thinking e quando devo usar?

Por padrão, só o raciocínio da interação atual é mantido. Com preserve_thinking: true, o modelo guarda toda a cadeia de pensamento da conversa. Use em loops de agente multi-etapas.

Como o Qwen3.6-Plus se compara ao Claude Opus 4.5?

Claude lidera no SWE-bench Verified (80,9% vs 78,8%) e no OSWorld-Verified (66,3% vs 62,5%). Qwen3.6-Plus domina Terminal-Bench 2.0 (61,6% vs 59,3%), MCPMark (48,2% vs 42,3%), DeepPlanning (41,5% vs 33,9%) e GPQA (90,4% vs 87,0%).

Posso usar Qwen3.6-Plus com Claude Code?

Sim. Defina ANTHROPIC_BASE_URL para o endpoint Anthropic do Dashscope, ANTHROPIC_MODEL para qwen3.6-plus e ANTHROPIC_AUTH_TOKEN para sua chave de API.

O Qwen3.6-Plus é open source?

O modelo hospedado não é, mas variantes menores com pesos públicos serão lançadas em dias.

Como obtenho acesso gratuito?

Instale o Qwen Code (npm install -g @qwen-code/qwen-code@latest), rode qwen e use /auth para ativar 1.000 chamadas diárias gratuitas via OAuth.

Qual janela de contexto ele suporta?

1 milhão de tokens por padrão. Alguns benchmarks usaram 256K para comparação, mas a API suporta 1M.

Como testo a integração da API antes do deploy?

Importe o endpoint no Apidog, adicione sua chave de API como variável de ambiente, escreva asserções e use o Smart Mock para testar offline. Encadeie requisições em Cenários de Teste para validar comportamento multi-turn de ponta a ponta.

Holo3: O Melhor Modelo de Uso do Computador?

Lucas — Thu, 02 Apr 2026 08:51:12 +0000

RESUMO

A H Company lançou o Holo3 em 31 de março de 2026, um modelo de mistura de especialistas que alcançou 78,85% no OSWorld-Verified, a pontuação mais alta já registrada no principal benchmark de uso de computador desktop. Ele supera o GPT-5.4 e o Opus 4.6 por uma fração do custo. A API está ativa agora, e a variante 35B é de código aberto (open-weight) no HuggingFace sob a licença Apache 2.0.

Experimente o Apidog hoje

A lacuna de uso de computador que a maioria dos desenvolvedores não resolveu

Você já automatizou suas APIs e seu pipeline de CI/CD roda sem falhas, mas tarefas envolvendo software legado sem API, aplicativos desktop antigos ou operações multi-etapa cruzando várias interfaces de usuário continuam exigindo intervenção manual.

Ferramentas tradicionais de RPA (UiPath, Automation Anywhere) dependem de scripts frágeis baseados em coordenadas de tela, que quebram com mudanças simples na UI. A alternativa era trabalho manual.

A IA de uso de computador muda esse cenário. Modelos que visualizam capturas de tela e emitem comandos de clique, digitação e rolagem podem operar qualquer GUI sem necessidade de API. O Holo3, lançado pela H Company, é hoje o modelo mais forte disponível para esse tipo de automação.

💡 Se você automatiza fluxos de trabalho ou pipelines de teste envolvendo software desktop, vale a pena conhecer a API do Holo3 agora. E, se utiliza o Apidog para projetar e testar APIs, veja abaixo como integrar chamadas do Holo3 ao seu fluxo.

O que é Holo3?

Holo3 é um modelo de uso de computador: você fornece uma captura de tela de um desktop ou navegador e uma tarefa; o modelo retorna ações (cliques, teclas, comandos de rolagem) para executar na tela. Você captura o resultado, envia nova captura, e repete até a tarefa terminar.

A H Company oferece duas versões:

Holo3-122B-A10B – Principal modelo. 122B parâmetros totais, 10B ativos (MoE esparso). Disponível via API hospedada em hcompany.ai/holo-models-api. Recordista nos benchmarks.
Holo3-35B-A3B – 35B totais, 3B ativos. Open-weight no HuggingFace, licença Apache 2.0. Disponível no nível gratuito da API e self-hostable.

A arquitetura MoE ativa só uma fração dos parâmetros por token, reduzindo custo de execução em relação ao total de parâmetros. Segundo a H Company, o Holo3-122B-A10B custa menos por tarefa que GPT-5.4 e Opus 4.6.

OSWorld-Verified: o que o benchmark realmente mede

O OSWorld-Verified é o benchmark referência para IA de uso de computador. Ao invés de avaliar somente saída textual, testa a execução real: o agente deve completar tarefas em um desktop real, e o sucesso é verificado pelo estado do sistema após a execução.

Tarefas avaliadas incluem:

Ações simples de aplicativo (abrir arquivo, preencher formulário)
Fluxos entre aplicativos (extrair valor de PDF, atualizar planilha, enviar e-mail)
Sequências multi-app de longo horizonte, exigindo raciocínio e manutenção de contexto

O Holo3-122B-A10B atinge 78,85% no OSWorld-Verified. Para comparação: até recentemente, 40% era considerado topo de linha; modelos anteriores de Anthropic e OpenAI ficavam entre 60-65%.

Nos Benchmarks Corporativos Internos da H Company (486 tarefas em E-commerce, negócios, colaboração e multi-app), o Holo3 se destaca em fluxos multi-aplicativo — coordenando dados entre vários sistemas.

Como o Holo3 foi treinado: o Ciclo de Aprendizagem Agêntico

Ao contrário de modelos baseados só em demonstrações estáticas, o Holo3 foi treinado num ciclo contínuo chamado Ciclo de Aprendizagem Agêntico:

Dados de Navegação Sintéticos – Instruções humanas e geradas criam exemplos específicos de navegação.
Aumento Fora do Domínio – Os cenários são expandidos para cobrir estados de UI inesperados e casos de borda.
Aprendizado por Reforço Curado – Cada amostra é filtrada e usada em pipeline de RL para maximizar a taxa de conclusão de tarefas.

O treinamento ocorre na Fábrica de Ambientes Sintéticos: agentes criam apps web completos baseados em cenários, com tarefas verificáveis e validação ponta-a-ponta. Isso garante aprendizado em workflows realistas e não exemplos simplificados.

O resultado: o Holo3 supera modelos Qwen3.5 com mais parâmetros nos mesmos benchmarks. A metodologia de treinamento é o diferencial.

Como chamar a API do Holo3

A API do Holo3 segue o padrão de loop: captura de tela → ação → repetir. Veja como integrar:

1. Configurar autenticação

# Base URL da API H Company
https://api.hcompany.ai/v1

# Headers
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Obtenha sua chave de API em hcompany.ai/holo-models-api. O nível gratuito cobre o Holo3-35B-A3B.

2. Enviar uma captura de tela com tarefa

import base64
import httpx
import pyautogui

screenshot = pyautogui.screenshot()
screenshot.save("/tmp/screen.png")

with open("/tmp/screen.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = httpx.post(
    "https://api.hcompany.ai/v1/computer-use",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "holo3-122b-a10b",
        "task": "Open the invoice folder and find the most recent PDF",
        "screenshot": image_b64,
        "screen_width": 1920,
        "screen_height": 1080
    }
)

action = response.json()
print(action)

3. Analisar e executar a ação retornada

A resposta traz ações estruturadas para executar na máquina host:

{
  "action_type": "click",
  "coordinate": [245, 380],
  "reasoning": "The invoice folder icon is visible at this position"
}

Tipos comuns: click, double_click, right_click, type, key, scroll, screenshot_request (se o modelo precisar de nova visão), e task_complete.

4. Repetir até a tarefa ser concluída

def run_computer_use_task(task: str, max_steps: int = 20):
    for step in range(max_steps):
        screenshot = capture_screen()
        response = call_holo3_api(task, screenshot)
        action = response["action"]

        if action["action_type"] == "task_complete":
            print(f"Done in {step + 1} steps")
            return response["result"]

        execute_action(action)

    raise TimeoutError("Task not completed within step limit")

Testando chamadas da API do Holo3 com Apidog

Ao integrar a API do Holo3, valide sua automação para garantir estabilidade. O Apidog facilita esse processo.

Importar o endpoint:

No Apidog, crie uma requisição HTTP para https://api.hcompany.ai/v1/computer-use. Use variáveis de ambiente para as chaves de autenticação.

Configurar validação de resposta:

Adicione asserções de teste no Apidog para checar a estrutura das respostas:

// No script pós-resposta do Apidog
pm.test("Action type is valid", () => {
    const validActions = ["click", "type", "key", "scroll", "task_complete", "screenshot_request"];
    pm.expect(validActions).to.include(pm.response.json().action.action_type);
});

pm.test("Coordinates are within screen bounds", () => {
    const action = pm.response.json().action;
    if (action.coordinate) {
        pm.expect(action.coordinate[0]).to.be.within(0, 1920);
        pm.expect(action.coordinate[1]).to.be.within(0, 1080);
    }
});

Simular a API durante o desenvolvimento:

Use o Smart Mock do Apidog para gerar respostas realistas do Holo3 sem consumir créditos da API real. Isso permite desenvolver e testar o frontend ou orquestração em paralelo.

Executar cenários de teste:

Encadeie múltiplas requisições do Holo3 em um Cenário de Teste do Apidog para simular fluxos multi-etapas. Assim, você valida a sequência de ações antes de rodar em ambiente real.

Holo3 vs. Claude Computer Use vs. OpenAI Operator

	Holo3-122B	Holo3-35B	Claude Computer Use	OpenAI Operator
OSWorld-Verified	78,85%	~55% (est.)	~65%	~62%
Acesso à API	Sim	Sim (grátis)	Sim	Sim
Pesos abertos	Não	Sim (Apache 2.0)	Não	Não
Auto-hospedável	Não	Sim	Não	Não
Custo vs. GPT-5.4	Menor	Muito menor	Comparável	Preço do GPT-5.4
Melhor para	Produção	Dev/teste/OSS	Ecossistema Anthropic	Ecossistema OpenAI

A escolha depende do seu stack:

Holo3-122B: máxima precisão para produção crítica em fluxos multi-app.
Holo3-35B: ideal para desenvolvimento, testes, projetos open source, ou se quiser hospedar localmente.
Claude Computer Use: integração direta no ecossistema Anthropic.
OpenAI Operator: se já usa GPT-5.4 e quer unificar fornecedores.

Casos de uso empresariais

O Holo3 resolve fluxos de trabalho que não têm integração limpa via API:

Entrada de dados em sistemas legados: ERPs ou CRMs antigos, sem API REST. O Holo3 interage direto na UI.
Reconciliação entre plataformas: Extrair dados de PDF, validar em planilha, atualizar painel externo — tudo autônomo.
Testes de regressão web: Esqueça scripts Selenium frágeis. Descreva a tarefa em linguagem natural e o Holo3 executa, adaptando-se a mudanças na UI.
Inteligência competitiva: Extraia dados estruturados de sites que bloqueiam scraping tradicional.

Benchmarks internos mostram o Holo3 com desempenho consistente em E-commerce, Negócios, Colaboração e especialmente Multi-App, onde a metodologia de treinamento se destaca.

Próximos passos: Agência Adaptativa

O próximo objetivo da H Company é a Agência Adaptativa — modelos capazes de navegar em softwares empresariais inéditos, aprendendo a UI em tempo real, sem depender de dados prévios do ambiente.

Os modelos atuais, incluindo o Holo3, ainda dependem de ambientes conhecidos para desempenho ideal. Com Agência Adaptativa, o modelo construiria um modelo funcional do software ao interagir pela primeira vez, eliminando a última limitação para automação IA total em empresas.

Conclusão

O Holo3 eleva o padrão de automação desktop: atinge 78,85% no OSWorld-Verified e supera alternativas Claude e GPT em tarefas multi-etapas complexas. O modelo Holo3-35B-A3B é gratuito e open-weight (Apache 2.0), facilitando testes e validação por desenvolvedores.

A integração é direta: capture a tela, envie via POST para a API, execute a ação recebida e repita. O Apidog torna esse ciclo confiável — validando respostas, simulando durante o desenvolvimento e encadeando cenários de teste.

Se você constrói automação para GUIs de desktop, experimente o Apidog gratuitamente e valide sua integração Holo3 antes de entrar em produção.

FAQ

O que é Holo3?

O Holo3 é um modelo de IA de uso de computador da H Company que recebe capturas de tela como entrada e retorna ações (cliques, toques de tecla, rolagens) para completar tarefas em um desktop ou navegador. Ele alcança 78,85% no benchmark OSWorld-Verified, o resultado mais alto registrado nesse teste.

O Holo3 é de código aberto?

A variante menor, Holo3-35B-A3B, é open-weight (licença Apache 2.0) e disponível no HuggingFace. O Holo3-122B-A10B é apenas via API. Ambos estão acessíveis via API da H Company, com nível gratuito para o 35B.

Como funciona o benchmark OSWorld?

O OSWorld testa agentes de IA em tarefas reais: navegação web, gerenciamento de arquivos, fluxos multi-aplicativo. A verificação é feita pelo estado real do sistema após execução, não apenas saída textual.

Como o Holo3 se compara ao Claude Computer Use?

O Holo3-122B pontua mais alto no OSWorld-Verified (78,85% vs. ~65% para Claude) e tem custo menor por tarefa. Claude Computer Use é vantajoso para equipes já integradas ao ecossistema Anthropic.

Posso executar o Holo3 localmente?

Sim, usando o Holo3-35B-A3B — pesos disponíveis no HuggingFace sob Apache 2.0. O 122B é apenas via API.

Principais casos de uso para APIs de uso de computador?

Automação de sistemas legados, fluxos multi-app de dados, testes de regressão web sem seletores frágeis, inteligência competitiva e qualquer workflow desktop que hoje exige intervenção manual.

Como testar minha integração da API do Holo3?

Use o Apidog para importar endpoints, configurar validações de resposta, simular a API e encadear testes. Isso identifica problemas antes de rodar automação em produção.

O que é "Agência Adaptativa" no roadmap do Holo3?

Modelos capazes de navegar em softwares empresariais inéditos, aprendendo a UI em tempo real, sem depender de dados de treinamento prévios — eliminando o maior gargalo da automação IA em empresas.

Ataque à cadeia de suprimentos axios@1.14.1: O que fazer agora

Lucas — Thu, 02 Apr 2026 08:47:54 +0000

Em resumo

Em 30 e 31 de março de 2026, as versões 1.14.1 e 0.30.4 do axios foram comprometidas no npm com uma dependência maliciosa que instala um cavalo de Troia de acesso remoto (RAT) em máquinas infectadas. Ambas as versões foram despublicadas. A versão segura é a 1.14.0. Se você instalou axios@1.14.1 ou 0.30.4, trate a máquina como comprometida e rotacione todas as credenciais imediatamente.

Experimente o Apidog hoje

O que é axios e por que isso importa

axios tem 100 milhões de downloads semanais no npm. É o cliente HTTP em inúmeros frameworks de frontend, serviços de backend Node.js e aplicações corporativas. Quando um pacote tão fundamental é comprometido, o raio de impacto é enorme — desenvolvedores que executaram npm install em uma pequena janela de tempo entre 30 e 31 de março instalaram malware em suas máquinas sem saber.

Este não é um risco hipotético de cadeia de suprimentos. Aconteceu, foi confirmado, e a carga útil (payload) era séria: um cavalo de Troia de acesso remoto em múltiplas etapas capaz de executar comandos arbitrários, exfiltrar dados do sistema e persistir em máquinas infectadas.

Se sua equipe usa axios, e você utiliza o Apidog para projetar e testar suas integrações de cliente HTTP, leia isto antes do seu próximo deploy.

Cronologia do ataque

30 de março de 2026 — 23:59:12 UTC:

Um pacote malicioso chamado plain-crypto-js@4.2.1 é publicado no npm por uma conta usando nrwise@proton.me. Uma versão anterior limpa (4.2.0) havia sido publicada 18 horas antes como um typosquat da biblioteca legítima crypto-js.

31 de março de 2026 — 00:05:41 UTC:

A detecção automatizada de malware do Socket sinaliza plain-crypto-js@4.2.1 como malicioso — seis minutos após ser publicado.

31 de março de 2026 — pouco depois da meia-noite:

axios@1.14.1 é publicado no npm, incluindo plain-crypto-js@4.2.1 como uma dependência. O lançamento não aparece nas tags oficiais do repositório axios no GitHub. A tag legítima mais recente permanece v1.14.0.

31 de março de 2026 — manhã:

A issue #10604 do GitHub é aberta publicamente, relatando que axios@1.14.1 e axios@0.30.4 foram comprometidos. Os mantenedores do Axios confirmam que inicialmente não conseguem revogar o acesso do invasor — a conta comprometida tem permissões npm superiores às dos mantenedores legítimos.

31 de março de 2026:

Ambas as versões axios@1.14.1 e axios@0.30.4 são despublicadas do npm. Os mantenedores do Axios começam a revogar tokens, apertar os controles de publicação e investigar como um token npm de longa duração foi explorado para obter acesso de publicação não autorizado.

Como o ataque funcionou

O ataque explorou uma falha no fluxo de trabalho de publicação do axios: um token npm de longa duração foi usado em conjunto com a publicação confiável. O invasor — provavelmente após comprometer as credenciais de um mantenedor — usou este token para publicar uma nova versão fora do processo de lançamento normal.

A nova versão introduziu plain-crypto-js@4.2.1 como uma dependência. O nome do pacote foi projetado para parecer um utilitário de criptografia legítimo; a versão limpa anterior 4.2.0 estabeleceu um breve histórico para reduzir a suspeita.

Dentro de plain-crypto-js@4.2.1, a análise do Socket encontrou uma carga útil multiestágio:

Estágio 1 — Execução: O pacote executa código no momento da instalação (via scripts de ciclo de vida do npm) para instalar uma carga útil secundária.
Estágio 2 — Implantação do RAT: A carga útil instala um cavalo de Troia de acesso remoto que abre um backdoor persistente.
Estágio 3 — Exfiltração: O RAT é capaz de executar comandos arbitrários de shell enviados de um servidor C2, ler variáveis de ambiente e segredos do sistema de arquivos e enviar dados do sistema pela rede.

O RAT persiste após reinicializações. Ou seja, mesmo após remover o pacote npm, a máquina segue em risco até que o RAT seja explicitamente identificado e removido.

Fui afetado?

Você está potencialmente afetado se:

Executou npm install axios ou npm install (com axios em package.json) entre 30 de março, 23:59 UTC e 31 de março de 2026, meio-dia UTC.
Seu node_modules/axios/package.json mostra a versão 1.14.1 ou 0.30.4.
Seu package-lock.json ou yarn.lock resolve o axios para 1.14.1 ou 0.30.4.

Verifique imediatamente:

# Verificar versão instalada
npm list axios

# Checar lock file
grep '"axios"' package-lock.json | head -5

# Checar presença do plain-crypto-js
npm list plain-crypto-js
ls node_modules/plain-crypto-js 2>/dev/null && echo "INFECTADO" || echo "Não encontrado"

Se plain-crypto-js estiver presente em seu node_modules, você executou a versão maliciosa.

O que fazer agora

1. Atualize o axios imediatamente

npm install axios@1.14.0
# ou pin para a versão segura mais recente
npm install axios@latest

Verifique:

npm list axios
# Deve mostrar 1.14.0 ou superior (assim que uma 1.14.x limpa for publicada)

2. Se você instalou a versão comprometida

Não trate isso como uma atualização de dependência rotineira. Trate a máquina como comprometida:

Rotacione todos os segredos acessíveis dessa máquina: chaves de API, credenciais de banco de dados, chaves SSH, tokens de provedores de nuvem, variáveis .env.
Verifique suas variáveis de ambiente — o RAT visa especificamente segredos no ambiente de processo e no sistema de arquivos.
Audite as conexões de rede de saída do período afetado — procure por conexões para IPs desconhecidos.
Procure por persistência — verifique tarefas cron, scripts de inicialização e serviços systemd adicionados por volta do período do comprometimento.
Reinstale o sistema operacional da máquina se for um CI runner ou servidor de produção que teve a versão comprometida instalada. Se for um laptop de desenvolvedor, considere as credenciais comprometidas e rotacione tudo antes de considerá-lo limpo.

3. Audite seus pipelines de CI/CD

Se o pipeline de build executou npm install durante a janela de tempo, seu ambiente de CI pode ter sido comprometido. Verifique:

# Verificar logs de build do período afetado
# Procure por axios@1.14.1 em qualquer saída de instalação

# Verifique se o node_modules do CI está limpo
npm list axios plain-crypto-js

Rotacione quaisquer segredos aos quais seu pipeline de CI tenha acesso: chaves de deploy, credenciais de provedores de nuvem, tokens de registro.

4. Verifique seu arquivo de lock

Arquivos de lock (package-lock.json, yarn.lock) devem fixar versões exatas. Se o seu arquivo de lock tiver 1.14.1, regenere-o:

# Remover e regenerar
rm package-lock.json
npm install

Verifique se o novo arquivo de lock resolve o axios para uma versão segura antes de commitar.

Usando Apidog para auditar suas chamadas de API do axios

Se você usa o axios como seu cliente HTTP para fazer chamadas de API, o Apidog pode ajudá-lo a verificar se sua integração ainda está enviando as requisições corretas após a atualização da dependência.

Após atualizar para axios@1.14.0, importe seus endpoints de API existentes para o Apidog e execute uma rápida verificação de regressão para confirmar que o comportamento não mudou. Isso é especialmente útil se você estiver preocupado que a versão maliciosa possa ter adulterado as cargas úteis de requisição ou resposta — as asserções de resposta do Apidog permitem que você valide valores de campo exatos, cabeçalhos e códigos de status:

// Apidog post-response assertion
pm.test("Resposta limpa — sem campos injetados", () => {
    const body = pm.response.json();
    pm.expect(body).to.not.have.property('__injected');
    pm.expect(pm.response.headers.get('X-Injected-Header')).to.be.null;
});

Executar sua suíte de testes completa contra a versão atualizada do axios no Apidog fornece uma linha de base limpa e documentada antes de enviar para produção.

Experimente o Apidog gratuitamente para configurar testes de regressão de cliente HTTP.

Por que ataques de cadeia de suprimentos no npm são difíceis de parar

O ataque ao axios não é uma anomalia. É um padrão:

event-stream (2018): Um mantenedor malicioso adicionou uma carga útil visando carteiras de bitcoin. 8 milhões de downloads semanais.
ua-parser-js (2021): Comprometido para instalar um minerador de criptomoedas e um ladrão de senhas.
node-ipc (2022): Mantenedor adicionou intencionalmente código destrutivo visando IPs russos/bielorrussos.
xz utils (2024): Campanha de engenharia social de dois anos para criar um backdoor em uma biblioteca de compressão central do Linux.
axios (2026): Credenciais de mantenedor comprometidas usadas para publicar um RAT via uma dependência maliciosa.

O ponto central: confiança na conta de publicação, não no código. O modelo do npm concede acesso de publicação aos mantenedores, e se as credenciais de um mantenedor forem comprometidas, o invasor herda essa confiança.

Mitigações práticas:

Medida	O que faz
Arquivos de lock (`package-lock.json`)	Fixa versões exatas, previne atualizações silenciosas
`npm audit` no CI	Sinaliza vulnerabilidades conhecidas antes do deploy
Socket.dev / Snyk	Análise comportamental — sinaliza pacotes suspeitos mesmo antes da existência de CVEs
Autenticação de dois fatores no npm	Torna o comprometimento de credenciais mais difícil
`npm publish` com tokens de curta duração	Limita a janela de exposição caso um token vaze
Ler arquivos de lock em PRs	Detecta alterações inesperadas de dependência na revisão de código

A equipe do axios já reconheceu que tokens npm de longa duração estavam no centro do problema e está adotando controles de publicação mais rigorosos. Mas a solução depende do ecossistema como um todo, não só de pacotes individuais.

Indicadores de Comprometimento (IOCs)

Conforme análise do Socket:

Pacotes maliciosos: plain-crypto-js@4.2.1, axios@1.14.1, axios@0.30.4
E-mail do publicador: nrwise@proton.me
Comportamento: Conexões de rede no momento da instalação do npm, persistência do RAT, exfiltração de variáveis de ambiente
Versões seguras do axios: 1.14.0 e anteriores (exceto 0.30.4), 1.13.x, 1.12.x

Se suspeitar de infecção, registre um relatório com a segurança do npm em security@npmjs.com e preserve os logs.

Conclusão

O comprometimento do axios 1.14.1 reforça que a segurança de dependências é um processo contínuo. Fixe suas versões, execute ferramentas de análise comportamental como o Socket no seu CI, rotacione credenciais diante de qualquer anomalia e mantenha seus arquivos de lock sob revisão.

Se você precisa reconstruir a confiança na integração de API após atualizar o axios, o Apidog oferece os cenários de teste, asserções e ferramentas de mocking para validar o comportamento do seu cliente HTTP antes do deploy.

FAQ

Quais versões do axios foram comprometidas?

axios@1.14.1 e axios@0.30.4. Ambas foram despublicadas do npm. A versão segura é 1.14.0 (ou qualquer versão das linhas 1.13.x, 1.12.x).

O que a carga útil maliciosa do axios faz?

Inclui plain-crypto-js@4.2.1, que implanta uma carga útil multiestágio incluindo um cavalo de Troia de acesso remoto (RAT). O RAT pode executar comandos arbitrários de um servidor C2 remoto, exfiltrar variáveis de ambiente e segredos, e persistir após reinicializações.

Como sei se instalei a versão comprometida?

Execute npm list axios — se mostrar 1.14.1 ou 0.30.4, você está afetado. Verifique também npm list plain-crypto-js — se esse pacote estiver presente, o código malicioso foi executado em sua máquina.

Basta apenas atualizar o axios?

Não. A atualização remove a dependência maliciosa daqui para frente, mas o RAT já pode estar instalado e persistindo na máquina. Se você instalou a versão comprometida, rotacione todos os segredos e audite a máquina em busca de mecanismos de persistência.

Como o invasor publicou no npm sem ser um mantenedor?

O invasor provavelmente comprometeu as credenciais de um mantenedor e explorou um token npm de longa duração que tinha acesso de publicação. A equipe do axios está investigando e apertando os controles de publicação.

Qual a diferença entre isso e uma vulnerabilidade comum?

Uma vulnerabilidade é uma falha em um código legítimo. Um ataque à cadeia de suprimentos introduz código malicioso através de um canal de publicação confiável. O código comprometido nunca esteve no repositório GitHub do axios — ele foi injetado diretamente na publicação do npm.

Como posso proteger meus projetos de futuros ataques à cadeia de suprimentos?

Use arquivos de lock, execute npm audit no CI, adicione uma ferramenta como Socket.dev para análise comportamental, habilite 2FA em contas npm, use tokens de publicação de curta duração e audite as diferenças de seus arquivos de lock na revisão de código.