Detalhes das dimensões para criar GIF com GPT Image 2.6 Sunburst: 4 layouts de mosaico e limite de dimensões de 2 a 16 quadros

Nota do autor: ao gerar GIFs com o GPT Image 2.6 Sunburst, size se refere à dimensão de um quadro individual; a restrição real se aplica ao mosaico formado por todos os quadros. Este artigo detalha essas regras item por item em tabelas e mostra os limites de dimensão disponíveis para cada número de quadros.

Muitos desenvolvedores, ao usar gpt-image-2.6-sunburst para criar GIFs pela primeira vez, se deparam com esta situação: definem size como 1024×1024 e apenas 2 quadros em frame_count, mas a API retorna 400 diretamente. O motivo é que as regras de dimensão para GIF são diferentes das de imagens estáticas. Este artigo apresenta o método de conversão em três etapas: “dimensão do quadro individual → layout do mosaico → restrições do mosaico”, para ajudar você a determinar se qualquer combinação de size e frame_count passa na validação.

Isto não é uma simples tradução da documentação de parâmetros. Os valores-limite deste artigo vêm de medições reais feitas em 2026-11-09 no canal oficial de encaminhamento; cada limite máximo nas tabelas inclui o processo de cálculo, para você conferir por conta própria.

Valor principal: depois de ler este artigo, você conseguirá escolher a dimensão de quadro individual adequada de acordo com o número de quadros, evitar erros como GIF frames exceed the total request pixel budget e saber como decidir entre 512×512, 768×768 e 960×960.

Pontos essenciais sobre dimensões de GIF no GPT Image 2.6 Sunburst

Vamos começar com uma tabela para deixar claras as regras principais da geração de GIF e, depois, detalhamos cada uma.

Mecanismo de geração do sprite sheet no GIF do GPT Image 2.6

O GPT Image 2.6 Sunburst gera GIFs em duas etapas: primeiro, desenha todos os quadros em uma imagem grande seguindo uma grade fixa; depois, corta a imagem grande em quadros individuais e monta a animação conforme frame_duration_ms. Por isso, o limite de tamanho não considera um quadro isolado, mas sim o comprimento de cada lado, o total de pixels e a proporção entre o lado maior e o menor desse sprite sheet.

O layout é definido por faixas de contagem de quadros e não é organizado de forma compacta conforme a quantidade real de quadros. Por exemplo, se frame_count for definido como 2, o sistema ainda usa o layout 4×2. O exemplo do material de referência comprova isso: um quadro de 2048×2048, com apenas 2 quadros, exige um sprite sheet de 8192×4096. Na estimativa, use sempre o “número de células do layout”, nunca o “número real de quadros”.

Interpretação dos parâmetros básicos de GIF do GPT Image 2.6

Além de size, o GIF tem dois parâmetros exclusivos: frame_count controla o número de quadros e frame_duration_ms controla a duração de cada quadro. A duração total é igual ao número de quadros multiplicado pela duração de cada quadro. Por exemplo, 2 quadros × 100ms resultam em um loop de 0,2 segundo.

O comportamento de frame_count fora da faixa exige atenção especial. Ao enviar 1 ou 17, a API não retorna 400; em vez disso, ela descarta frame_count e frame_duration_ms e volta ao padrão de 9 quadros e 1.8 segundos. Ou seja, a requisição é “bem-sucedida”, mas o resultado não é o que você queria. Nesse caso, é necessário conferir o número real de quadros com uma ferramenta após a geração; o procedimento específico está na seção de início rápido.

Limites de dimensão do GIF Sunburst no GPT Image 2.6: análise detalhada

Esta seção é o ponto central do artigo. Juntando as restrições do mosaico com as regras de layout, dá para deduzir o limite de tamanho de cada faixa de número de quadros.

As quatro restrições do mosaico no GPT Image 2.6

A parte do limite superior é mais fácil de entender. O lado de 3840 e o total de 8,294,400 pixels são duas travas independentes e precisam ser atendidas ao mesmo tempo. Com poucos quadros, a largura do mosaico costuma esbarrar primeiro no limite de lado; com muitos quadros, o total de pixels normalmente se esgota antes.

O limite inferior costuma passar despercebido. Nos testes, os 589,824 rejeitados são exatamente 768×768, o que corresponde a um mosaico 3×3 com 9 quadros de 256×256 cada. Já os 665,856 aprovados são 816×816, ou seja, 9 quadros de 272×272. Daí se deduz que quadros pequenos demais combinados com layouts de poucas células também podem ser rejeitados por deixar o mosaico pequeno demais. Por exemplo, um layout 4×2 com quadros de 256×256 resulta num mosaico de apenas 1024×512, totalizando 524,288 pixels, abaixo do mínimo. Ou seja, até a estratégia de “reduzir o tamanho para economizar” tem um piso.

O efeito da proporção entre lado maior e menor fica mais visível em quadros não quadrados. Fazendo a conta com layout 4×2, quando o quadro é 16:9 a proporção largura/altura do mosaico fica em torno de 3.56:1, acima de 3:1; passando para layouts 3×3 ou 4×4, a proporção cai. Vale destacar que isso é uma dedução a partir das regras — o ideal é confirmar com testes reais antes de colocar em produção.

Limite superior por quadro quadrado em cada quantidade de quadros do GPT Image 2.6

Os limites abaixo consideram “quadro individual quadrado + largura e altura múltiplas de 16” e podem ser consultados diretamente.

Dois detalhes precisam ser explicados.

• 10–12 quadros são calculados como 12 células: o layout é 4×3; mesmo que você queira apenas 10 quadros, o mosaico ocupa pixels com base em 12 células. Nos testes, 12 quadros com 832² excederam em apenas 12.288 pixels e foram rejeitados, o que mostra que o orçamento é aplicado com rigor.
• 2–8 quadros são limitados pela largura do lado: nessa faixa ainda há folga no total de pixels, mas a largura do mosaico é 4 vezes a largura de um quadro individual; por isso, 960 já é o limite. Com 1024, a largura do mosaico passaria a 4096.

Como escolher os tamanhos comuns do GPT Image 2.6

Ao trocar os limites acima por escolhas práticas, chegamos às seguintes conclusões:

O 1024×1024 é muito usado em imagens estáticas, mas é totalmente inviável em GIF. Nos casos de 2–8 e 10–12 quadros, a largura da montagem é 4096, ultrapassando 3840; com 9 quadros, a montagem fica 3072×3072, com total de 9.437.184 pixels, ultrapassando o orçamento; com 13–16 quadros, a largura da montagem também é 4096. Por isso, ao migrar de imagens estáticas para GIF, a primeira coisa a fazer é reduzir o tamanho padrão.

Se precisar de uma imagem horizontal, recomendo 9 quadros com 1280×720. Nesse caso, a montagem fica em layout 3×3, exatamente 3840×2160, proporção de 16:9, atendendo às três restrições.

💡 Sugestão de escolha: os limites de tamanho são resultados calculados com base nas regras, e o próprio modelo pode ajustar o orçamento. Antes de entrar em produção, recomendo rodar um conjunto de testes de limite no APIYI apiyi.com com quality: "low", confirmando com o menor custo a combinação de tamanhos que você costuma usar.

Introdução rápida ao GIF Sunburst do GPT Image 2.6

Exemplo minimalista de GIF com GPT Image 2.6

Aqui está o exemplo de baixo custo do material de referência: 2 quadros, 100 ms por quadro, duração total de 0,2 segundo, gerando uma animação em loop de um círculo amarelo que se desloca para a direita e volta à posição original. Campos como frame_count são exclusivos de GIF — aqui usamos requests para enviar o JSON direto, o que é o mais intuitivo.

import base64, requests

resp = requests.post(
    "https://api.apiyi.com/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "gpt-image-2.6-sunburst",
        "prompt": "A minimal two-frame looping animation of a yellow circle moving slightly right and returning to its starting position on a plain white background, no text, seamless loop.",
        "output_format": "gif",
        "quality": "low",
        "size": "512x512",
        "frame_count": 2,
        "frame_duration_ms": 100,
        "n": 1,
    },
    timeout=300,
)
resp.raise_for_status()
open("circle.gif", "wb").write(base64.b64decode(resp.json()["data"][0]["b64_json"]))

Ao escrever o comando, descreva claramente três coisas: qual é o elemento principal, como ele se move e como o loop funciona. Descrições como “voltar à posição inicial” e “seamless loop” ajudam o primeiro e o último quadro a se conectarem de forma mais natural.

Pré-verificação de tamanho de GIF do GPT Image 2.6 e implementação completa

Em ambiente de produção, recomenda-se fazer uma pré-verificação local antes da requisição, interceptando antecipadamente tamanhos inválidos e economizando uma ida e volta de erro 400. O código abaixo transforma a tabela de layout e as restrições deste artigo em funções, sendo compatível tanto com a interface de geração quanto com a de edição.

import base64
import requests
from typing import Optional

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.apiyi.com/v1"  # Interface compatível com OpenAI da APIYI

MAX_EDGE = 3840
MAX_PIXELS = 8_294_400   # 3840 x 2160
MIN_PIXELS = 655_360     # próximo do limite inferior medido, usado apenas como alerta
MAX_RATIO = 3.0


def sheet_layout(frame_count: int) -> tuple[int, int]:
    """Retorna o layout fixo do mosaico (colunas, linhas) de acordo com o número de quadros"""
    if 2 <= frame_count <= 8:
        return 4, 2
    if frame_count == 9:
        return 3, 3
    if 10 <= frame_count <= 12:
        return 4, 3
    if 13 <= frame_count <= 16:
        return 4, 4
    raise ValueError("frame_count 必须在 2-16 之间，否则会被静默回退到 9 帧")


def check_gif_size(width: int, height: int, frame_count: int) -> list[str]:
    """Retorna a lista de problemas; lista vazia significa que a pré-verificação passou"""
    issues = []
    if width % 16 or height % 16:
        issues.append("宽高必须是 16 的倍数")
    cols, rows = sheet_layout(frame_count)
    sw, sh = cols * width, rows * height
    total = sw * sh
    if max(sw, sh) > MAX_EDGE:
        issues.append(f"拼图 {sw}x{sh} 单边超过 {MAX_EDGE}")
    if total > MAX_PIXELS:
        issues.append(f"拼图总像素 {total:,} 超过 {MAX_PIXELS:,}")
    if total < MIN_PIXELS:
        issues.append(f"拼图总像素 {total:,} 低于约 {MIN_PIXELS:,}，可能被拒")
    if max(sw, sh) / min(sw, sh) > MAX_RATIO:
        issues.append(f"拼图长短边比 {max(sw, sh) / min(sw, sh):.2f} 超过 3:1")
    return issues


def create_gif(
    prompt: str,
    size: str = "512x512",
    frame_count: int = 9,
    frame_duration_ms: int = 200,
    quality: str = "low",
    image_url: Optional[str] = None,
    out_path: str = "output.gif",
) -> str:
    w, h = map(int, size.lower().split("x"))
    problems = check_gif_size(w, h, frame_count)
    if problems:
        raise ValueError("尺寸预检未通过: " + "; ".join(problems))

    payload = {
        "model": "gpt-image-2.6-sunburst",
        "prompt": prompt,
        "output_format": "gif",
        "quality": quality,
        "size": size,
        "frame_count": frame_count,
        "frame_duration_ms": frame_duration_ms,
        "n": 1,
    }
    endpoint = "images/generations"
    if image_url:  # Endpoint de edição: a primeira imagem é o corpo principal da animação
        endpoint = "images/edits"
        payload["images"] = [{"image_url": image_url}]

    resp = requests.post(
        f"{BASE_URL}/{endpoint}",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json=payload,
        timeout=600,
    )
    if resp.status_code == 400:
        raise RuntimeError(f"参数被拒（多为 size 超界）: {resp.text}")
    resp.raise_for_status()

    item = resp.json()["data"][0]
    if item.get("b64_json"):
        data = base64.b64decode(item["b64_json"])
    else:
        data = requests.get(item["url"], timeout=120).content
    with open(out_path, "wb") as f:
        f.write(data)
    return out_path


if __name__ == "__main__":
    print(check_gif_size(768, 768, 16))   # Esperado: total de pixels acima do orçamento
    print(check_gif_size(1280, 720, 9))   # Esperado: [] aprovado
    create_gif(
        prompt="让这只猫跳一小段舞，纯色背景，固定镜头，最后一个动作回到起始姿势",
        size="512x512",
        frame_count=16,
        frame_duration_ms=100,
        image_url="https://example.com/cat.png",
        out_path="cat_dance.gif",
    )

Verificar a contagem real de frames do GIF do GPT Image 2.6 com ffprobe

Quando frame_count está fora do intervalo permitido, o sistema volta silenciosamente para 9 frames. Por isso, em tarefas em lote, é melhor incluir uma etapa de verificação da contagem real de frames:

ffprobe -v error -count_frames -select_streams v:0 \
  -show_entries stream=nb_read_frames -of csv=p=0 circle.gif

O exemplo mínimo deve gerar 2. Se gerar 9, significa que o parâmetro de contagem de frames não foi aplicado; é preciso verificar se o valor informado está entre 2 e 16.

Limitações funcionais do GIF no GPT Image 2.6

O modo GIF não oferece suporte às seguintes capacidades; não as inclua na requisição:

• stream para saída em streaming e visualização progressiva de imagens parciais
• output_compression personalizado
• prompt_rewriter

Além disso, frame_count e frame_duration_ms são usados apenas para GIF; não os envie em requisições para PNG, JPEG, WebP ou SVG.

🚀 Início rápido: recomendo registrar-se na APIYI apiyi.com e usar a cota gratuita de testes para novos usuários. Primeiro, execute o fluxo completo com 512×512, 2 frames e quality: "low"; depois, aumente gradualmente a quantidade de frames e o tamanho. A plataforma oferece uma interface compatível com OpenAI, e uma única chave API permite chamar modelos populares como o GPT Image.

Perguntas frequentes (FAQ)

Principais conclusões sobre as dimensões de GIF no GPT Image 2.6 Sunburst

• size é a dimensão de um único quadro: a restrição vale para o mosaico compartilhado por todos os quadros, não para o quadro isolado
• O layout é fixo por faixa: são quatro layouts — 4×2, 3×3, 4×3 e 4×4 — correspondentes a 2–8, 9, 10–12 e 13–16 quadros
• Três restrições rígidas: cada lado do mosaico ≤ 3840, total de pixels ≤ 8,294,400 e proporção entre lado maior e menor ≤ 3:1
• A dimensão mais segura é 512×512: funciona com todos os 2–16 quadros; 768² suporta no máximo 12 quadros e 960² no máximo 9
• 1024² é totalmente inviável: ao migrar parâmetros de uma imagem estática, é preciso reduzir a dimensão antes
• Contagens de quadros fora do limite causam fallback silencioso: recomenda-se validar o intervalo no cliente e conferir a contagem de quadros com ffprobe após a geração
• Validação de baixo custo: no APIYI apiyi.com, rode os testes de limite com quality: "low" e gaste o mínimo

Conclusão

As regras de dimensionamento para gerar GIFs com o GPT Image 2.6 Sunburst se resumem a três passos de cálculo:

1. Defina o layout primeiro: a partir de frame_count, encontre o layout correspondente — 4×2, 3×3, 4×3 ou 4×4
2. Calcule o mosaico: multiplique largura e altura de um quadro pelas linhas e colunas do layout para obter largura, altura e total de pixels do mosaico
3. Valide no final: confira os limites mínimo e máximo de cada lado e do total de pixels, a proporção entre os lados e se largura e altura são múltiplos de 16

No uso do dia a dia, 512×512 é o padrão de melhor compatibilidade; quando você precisa de uma imagem maior, 9 quadros com 960×960 ou 1280×720 aproveitam o orçamento por completo. Integrando a função de pré-verificação deste artigo ao código do seu produto, a maior parte dos erros 400 pode ser detectada localmente antes de acontecer.

Recomendamos validar rapidamente suas combinações de dimensões pelo APIYI apiyi.com: a plataforma oferece cota de teste gratuita e uma interface unificada compatível com OpenAI, ideal para concluir os testes de limite antes da integração oficial.

📚 Materiais de Referência

1. Central de Documentação APIYI – Geração de GIF com animação em loop no GPT Image 2.6: descrição dos parâmetros oficiais e dos limites verificados na prática
2. Link: docs.apiyi.com/api-capabilities/gpt-image-2/gpt-image-2-6

3. Descrição: inclui a faixa de parâmetros do GIF, as restrições de montagem das imagens, exemplos de erro e o uso da interface de edição

4. Documentação oficial do FFmpeg – ffprobe: ferramenta para inspecionar metadados de áudio, vídeo e GIF

5. Link: ffmpeg.org/ffprobe.html
6. Descrição: usada para conferir a quantidade real de quadros e a duração de cada quadro do GIF gerado

Autor: Equipe técnica da APIYI
Contato técnico: se você tiver problemas na configuração do tamanho do GIF, fale com a gente pela página inicial do site oficial da APIYI para obter mais suporte de integração.

Artigos relacionados

• Limitações ocultas da API GPT Image 2.6: 5 tipos de limites na combinação de GIF, SVG e edição localizada: Entenda as limitações dos endpoints, os conflitos de parâmetros e os cuidados de migração para edição parcial de GIF, SVG e markup na API GPT Image 2.6, evitando o equívoco de que basta trocar o nome do modelo para usá-la.
• Parâmetro Complexity do GPT Image 2.6: como 3 níveis de “profundidade de pensamento” mudam a composição das imagens geradas: Entenda o novo parâmetro Complexity do GPT Image 2.6: como os níveis low/medium/high afetam o planejamento de cenas, em que ele difere de Quality e como testar e escolher os níveis de forma justa na API.
• ChatGPT Images 2.6 lançado: GIFs e imagens de referência disponíveis, geração de imagens 50% mais rápida; como usar GPT-Image-2.6 Flare e Sunburst: Análise do ChatGPT Images 2.6, lançado em 4/11/2026: GIF, imagens de referência reutilizáveis, edição por marcação e exportação SVG; critérios de escolha entre Flare e Sunburst, cinco níveis de custo em 1024×1024 e limites entre dados oficiais autodeclarados, rankings externos e informações desconhecidas.
• GPT-Image-2.6 vs. Nano Banana 2.1: diferenças em GIF, 4K e preço e como escolher: Compare GPT-Image-2.6 e Nano Banana 2.1 por formato de entrega: imagens animadas e vetoriais, 4K e múltiplas imagens de referência, dois métodos de avaliação de desempenho, dois modelos de cobrança e uma tabela de escolha para três tipos de tarefas.
• O que o Grok Imagine descontinuou hoje? Os modelos antigos ainda funcionam? Entenda os 4 pontos essenciais da migração para a versão 2.0: Em 2 de novembro de 2026, apenas o identificador grok-imagine-image-quality será descontinuado, e não todo o Grok Imagine; este artigo explica o alcance do impacto, as mudanças de preço, os parâmetros de qualidade e como migrar para a versão 2.0.
• Meu Deus! Krea 3, você vai acabar com o Nano Banana?: Como o Krea 3 se sai na criação de imagens publicitárias para marcas? Este artigo percorre em 5 etapas o fluxo do Ad Studio, do site oficial ao kit de marca e a 12 anúncios estáticos, com imagens oficiais, tabela de custos e 7 armadilhas.