Como usar a API do Veo 3.1

O Veo 3.1 é a mais recente iteração da família Veo de modelos de geração de vídeo do Google. Ele traz áudio nativo mais rico, melhor controle narrativo e cinematográfico, orientação multi-imagem e novos recursos de edição (transições de primeiro/último quadro, "ingredientes"/imagens de referência e fluxos de trabalho de extensão de cena). Para desenvolvedores, a maneira mais rápida de acessar o Veo 3.1 é a API (para integrações voltadas para o consumidor) e o Vertex AI (para cargas de trabalho corporativas e em nuvem).

O que é a API do Veo 3.1 e quais são seus principais recursos?

O Veo 3.1 é um modelo generativo de texto e imagem → vídeo do Google, projetado para produzir clipes cinematográficos curtos e de alta qualidade com áudio gerado nativamente (diálogos, dicas de ambiente, efeitos sonoros). O lançamento se concentra em melhorar a aderência aos prompts, a consistência dos caracteres, a geração de áudio e controles de edição mais granulares (por exemplo: transições do primeiro para o último quadro e orientação por meio de até três imagens de referência).

Principais capacidades (em resumo)

• Texto → Vídeo: Gere vídeos diretamente de prompts narrativos (diálogo e áudio incluídos).
• Imagem → Vídeo: Transforme uma imagem em uma curta cena animada. ()
• Imagens de referência (“Ingredientes para vídeo”): Fornecimento de até 3 imagens (caracteres, objetos, estilos) para manter a consistência visual em todas as saídas.
• Geração do primeiro e último quadro: Crie transições conectando duas imagens (o modelo gera quadros que se transformam suavemente entre elas, com áudio correspondente).
• Fluxos de trabalho de extensão de cena: Ferramentas para estender um clipe existente gerando novos clipes vinculados ao final de um vídeo anterior (observação: os recursos e o suporte diferem entre a API Gemini e a visualização do Vertex — consulte a seção “condições”).
• Áudio nativo e efeitos sonoros: O modelo pode sintetizar fala, som ambiente e efeitos sincronizados que correspondem aos visuais gerados.

Como usar a API do Veo 3.1 — quais são os pré-requisitos e condições?

O que você precisa antes de chamar a API?

1. Acesso e faturamento: O Veo 3.1 está em versão de pré-visualização paga — certifique-se de ter uma chave de API ou um projeto do Google Cloud com o Vertex AI habilitado e o faturamento configurado. Alguns recursos e variantes de modelo são limitados por região na versão de pré-visualização.
2. Cotas e restrições de visualização: Os modelos de pré-visualização geralmente têm limites de taxa de solicitação por projeto (exemplos: 10 RPM para variantes de pré-visualização) e limites de vídeos por solicitação. Consulte a página do modelo na documentação do Vertex AI/Gemini para obter os números exatos para sua conta.
3. Ativos de entrada e formato: Você pode gerar a partir de prompts de texto, de uma ou várias imagens, ou estender um vídeo existente gerado pelo Veo referenciando seu URI. Para fluxos de trabalho de imagem para vídeo, forneça imagens nos formatos suportados (URLs ou bytes, dependendo do ponto de extremidade).
4. Segurança e procedência: O conteúdo gerado deve estar em conformidade com as políticas de conteúdo do Google. Na pré-visualização, marcas d'água ou sinalizadores de uso podem aparecer; esteja preparado para lidar com as etapas de procedência e moderação de conteúdo em sua inscrição.

Quais métodos de autenticação são suportados?

• Chave API: Para endpoints hospedados no Gemini ou chaves da plataforma de API de terceiros, recomendo o CometAPI,  CometAPI oferecemos um preço muito menor que o preço oficial para ajudar você a integrar a API Veo 3.1 (veo3.1-pro; veo3.1)
• Credenciais do Google Cloud / ADC: Para o Vertex AI, use as credenciais padrão do aplicativo (conta de serviço/autenticação do gcloud) ou uma chave de API anexada ao seu projeto do Google Cloud.

Quais são os endpoints da API do Veo 3.1 e quais parâmetros são mais importantes?

Resposta curta: Você ligará para o API CometAPI ponto final de geração de vídeo (para acesso hospedado pela CometAPI, v1/chat/completions) . Ambos usam um corpo de solicitação JSON descrevendo o modelo, prompt(s) e um video/output configuração; trabalhos de vídeo maiores são retornados como operações de longa duração.

Pontos finais comuns (exemplos):

curl --location --request POST 'https://api.cometapi.com/v1/chat/completions' \  
--header 'Authorization: {{api-key}}' \  
--header 'Content-Type: application/json' \  
--data-raw '{  
"model": "veo3.1-pro",  
"stream": true,  
"messages":   
}'

Parâmetros típicos de solicitação (detalhamento lógico)

• modelo — identificador do modelo para o alvo (veo3.1-pro; nomes veo3.1 listados em referência de modelo).
• prompt / entrada — texto humano descrevendo a cena; pode incluir vários prompts ou instruções para várias tomadas, dependendo das capacidades do modelo. Use prompts estruturados para controlar os movimentos da câmera, a hora do dia, o humor e as indicações sonoras.
• referências_de_imagem — 1–3 URIs de imagem ou imagens base64 para guiar objetos/caracteres/estilos (o Veo 3.1 suporta múltiplas referências de imagem).
• vídeo — usado quando estendendo uma saída Veo anterior (passe o URI do vídeo inicial). Alguns recursos funcionam apenas em vídeos gerados pelo Veo.
• duração / fps / resolução / proporção de aspecto — selecione entre durações e formatos suportados (os modelos de visualização listam durações e taxas de quadros suportadas — por exemplo, 4, 6, 8s em alguns documentos de visualização; extensões podem permitir saídas mais longas no Flow/Studio).

O que são padrões e técnicas de uso avançado?

1) Manter a consistência dos personagens com imagens de referência

Forneça até três imagens de referência (rostos/poses/fantasia) para manter a aparência de um personagem em várias tomadas geradas. Fluxo típico:

1. Carregue ou codifique em linha suas imagens de referência.
2. Passe-os para dentro config.reference_images ao gerar cada tomada.
3. Use as mesmas imagens para chamadas de gerações subsequentes (ou combine com valores iniciais) para maximizar a consistência visual.

curl -s -X POST "https://api.cometapi.com/v1/chat/completions" \
-H "Authorization: Bearer cometapi_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "veo3.1-pro",
"messages": [
{
"role": "user",
"content": "Create a cinematic 6s shot: a fashion editorial on a city rooftop at golden hour. Keep the subject look consistent with the reference images."
}
],
"extra_body": {
"google": {
"referenceImages": [
{ "image": { "uri": "https://example.com/ref1.jpg" }, "referenceType": "asset" },
{ "image": { "uri": "https://example.com/ref2.jpg" }, "referenceType": "asset" },
{ "image": { "uri": "https://example.com/ref3.jpg" }, "referenceType": "asset" }
],
"config": {
"resolution": "1080p",
"durationSeconds": 6,
"fps": 24,
"aspectRatio": "16:9",
"generateAudio": true
}
}
}
}'

2) Transições de primeiro e último quadro (síntese de tomada)

Uso image (primeiro quadro) + config.last_frame para instruir o Veo a sintetizar o movimento intermediário. Isso é ideal para transições cinematográficas — produz interpolação visual natural e áudio sincronizado.

Providencie um primeiro quadro (image) E um último quadro (lastFrame) e o Veo 3.1 interpolará o movimento entre eles para produzir uma transição suave (com áudio opcional). Exemplo de cURL (REST) ​​— primeira + última imagem:

curl -s -X POST "https://api.cometapi.com/v1/chat/completions" \
-H "Authorization: Bearer cometapi_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "veo-3.1",
"messages": [
{
"role": "user",
"content": "Interpolate between these two images to create an 8s cinematic morph: from 'sunlit victorian parlor' (first) to 'overgrown ruin' (last). Add soft ambient sound."
}
],
"extra_body": {
"google": {
"image": { "uri": "https://example.com/first_frame.jpg" },
"lastFrame": { "uri": "https://example.com/last_frame.jpg" },
"config": {
"resolution": "1080p",
"durationSeconds": 8,
"fps": 24,
"aspectRatio": "16:9",
"generateAudio": true
}
}
}
}'

3) Extensão de cena (encadear múltiplas gerações)

Existem dois padrões:

• Abordagem API/Flow (recursos de visualização): Você passa um vídeo existente (um objeto de vídeo retornado ou URI) como video=video_to_extend para criar um clipe subsequente que seja consistente com a cena anterior. Use a resposta da operação para capturar a video.uri e insira-o na próxima chamada para ampliar a narrativa. Observação: a disponibilidade e o comportamento podem variar de acordo com a plataforma, portanto, valide na plataforma escolhida.
• Padrão de nuvens de vértice: O modelo de pré-visualização do Vertex tem limites mais rigorosos listados em documentos (por exemplo, a pré-visualização atual retorna apenas segmentos de 4/6/8 segundos). Portanto, para produzir saídas com duração de um minuto, você deve encadear várias solicitações e uni-las ao seu aplicativo ou usar as ferramentas oficiais de extensão de cena do mecanismo, quando disponíveis. Consulte a página "Pré-visualização do Veo 3.1" do Vertex para ver a matriz de suporte atual.

Verifique anteriormente gerado por Veo vídeo e estendê-lo para frente (adicionar segundos), preservando o estilo e a continuidade. A API exige que a entrada seja um vídeo gerado pelo Veo (extensões de MP4s arbitrários podem não ser suportadas). Você pode estender em saltos de 7s até os limites documentados (limites de pré-visualização do Veo se aplicam):

curl -s -X POST "https://api.cometapi.com/v1/chat/completions" \
-H "Authorization: Bearer cometapi_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "veo-3.1",
"messages": [
{
"role": "user",
"content": "Extend the last scene: the origami butterfly flies into the garden and a puppy runs up to the flower; continue action for ~7 seconds."
}
],
"extra_body": {
"google": {
"video": { "uri": "https://storage.googleapis.com/your-bucket/butterfly_video_id.mp4" },
"config": {
"numberOfVideos": 1,
"resolution": "720p",
"durationSeconds": 7,
"fps": 24,
"generateAudio": true
}
}
}
}'

4) Controle de áudio e diálogo

O Veo 3.1 gera áudio nativo (fala e efeitos) a partir de prompts. Dicas:

• Coloque quaisquer falas no seu prompt (coloque o diálogo entre aspas) para incentivar uma sincronização labial realista.
• Adicione descritores de áudio (“passos suaves da esquerda para a direita”, “crescendo de trovão abafado”) para moldar os efeitos sonoros e o clima.
• Use valores iniciais para reproduzir o mesmo resultado de áudio/visual em todas as execuções de teste.

5) Saídas determinísticas para testes (sementes)

Se você precisar de saídas repetíveis para testes CI ou A/B, forneça um seed parâmetro (uint32). Alterar o prompt ou as imagens de referência ainda alterará o resultado; a semente garante repetibilidade só quando todo o resto é idêntico.

6) Otimizações de custo e desempenho

• Produza menos lotes de trabalhos maiores: Onde permitido, defina sampleCount para produzir vários vídeos candidatos em uma solicitação (1–4) para reduzir a sobrecarga de configuração. ()
• Imagens de referência de cache e sementes de reutilização para reprodutibilidade, evitando reenviar binários grandes.
• Usar saídas do Cloud Storage (Vértice) para tamanhos de saída grandes para evitar retornar bytes brutos no corpo da solicitação.

7) Pipelines multietapas com outros modelos Gemini

Um pipeline útil: use um gerador de imagens estáticas (por exemplo, modelo de imagem Gemini) para criar ativos → passe as melhores imagens como image + referenceImages para Veo 3.1 → iterar prompts de áudio/diálogo com o modelo de texto para a narração gerada. A documentação do Gemini mostra explicitamente exemplos que encadeiam a geração de imagens e chamadas Veo.

Dicas práticas, pegadinhas e melhores práticas

• Use sementes quando você deseja saídas determinísticas e repetíveis entre execuções (mesmo prompt + mesmas referências + mesma semente → mesma geração).
• Mantenha as imagens de referência consistentes: mesmo corte, mesmo ângulo do rosto e roupas/fundo consistentes ajudam a modelo a manter a identidade e o estilo. Reutilize as mesmas três imagens em todas as fotos para preservar a continuidade.
• Prefira URIs GCS para produção: armazenar imagens e saídas no Cloud Storage evita limites de tamanho de transferência base64 e simplifica o encadeamento/extensão.
• Descreva explicitamente as transições e o áudio: para transições de primeira/última, adicione movimento de câmera, ritmo e efeitos sonoros/dicas de voz no prompt para melhor sincronização de áudio.
• Teste primeiro os loops curtos: itere com durações curtas (4–8s) enquanto ajusta prompts, sementes e imagens de referência e, em seguida, encadeie extensões para cenas mais longas.
• Confirme os nomes exatos dos campos: SDKs podem usar reference_images (estojo_de_cobra), referenceImages (camelCase) ou aninhado image objetos com content / gcsUri. Verifique a documentação do SDK ou o esquema do modelo Vertex para obter os nomes exatos das propriedades na versão que você usa.

Quanto custa o Veo 3.1 e como ele é cobrado?

Veo 3.1 é cobrado por segundo de vídeo gerado, e o Google expõe diversas variantes (por exemplo Padrão e pomposidade) com diferentes taxas por segundo. O preço publicado para desenvolvedores mostra exemplos de taxas de nível pago de US 0.40/segundo para Veo 3.1 Standard** e **US 0.15/segundo para Veo 3.1 Fast. A página de preços do Gemini também informa que você só será cobrado quando um vídeo for gerado com sucesso (tentativas malsucedidas podem não ser cobradas).

API do Veo 3.1 Preços no CometAPI

Conclusão — por que o Veo 3.1 é importante para os desenvolvedores agora

O Veo 3.1 representa um claro avanço na geração de vídeos por IA: áudio nativo mais rico, orientação por imagem de referência e novas primitivas de edição o tornam uma opção mais robusta para aplicativos de narrativa, pré-visualização e criação. Os recursos exatos do modelo diferem ligeiramente entre endpoints e compilações de pré-visualização (por exemplo, a diferença de versão entre CometAPI e Gemini) — portanto, teste e valide a variante do modelo que você pretende usar. Os exemplos neste guia fornecem um ponto de partida prático para prototipagem e produção.

Como acessar API do Veo 3.1 API

A CometAPI é uma plataforma de API unificada que agrega mais de 500 modelos de IA de provedores líderes — como a série GPT da OpenAI, a Gemini do Google, a Claude da Anthropic, a Midjourney e a Suno, entre outros — em uma interface única e amigável ao desenvolvedor. Ao oferecer autenticação, formatação de solicitações e tratamento de respostas consistentes, a CometAPI simplifica drasticamente a integração de recursos de IA em seus aplicativos. Seja para criar chatbots, geradores de imagens, compositores musicais ou pipelines de análise baseados em dados, a CometAPI permite iterar mais rapidamente, controlar custos e permanecer independente de fornecedores — tudo isso enquanto aproveita os avanços mais recentes em todo o ecossistema de IA.

Os desenvolvedores podem acessar API do Veo 3.1 através do CometAPI, a versão mais recente do modelo está sempre atualizado com o site oficial. Para começar, explore as capacidades do modelo no Playground e consulte o Guia de API para obter instruções detalhadas. Antes de acessar, certifique-se de ter feito login no CometAPI e obtido a chave da API. CometAPI oferecem um preço muito mais baixo que o preço oficial para ajudar você a se integrar.

Pronto para ir?→ Inscreva-se no CometAPI hoje mesmo !

Se você quiser saber mais dicas, guias e novidades sobre IA, siga-nos em VK, X e  Discord!