Détails des dimensions pour créer des GIF avec GPT Image 2.6 Sunburst : 4 dispositions de mosaïque et limites de taille de 2 à 16 images

Note de l’auteur : lorsque vous générez un GIF avec GPT Image 2.6 Sunburst, size correspond à la taille d’une seule frame ; la véritable limite s’applique à la mosaïque formée par l’ensemble des frames. Cet article détaille ces règles point par point dans un tableau et indique, pour chaque nombre de frames, les tailles maximales utilisables.

Beaucoup de développeurs qui utilisent gpt-image-2.6-sunburst pour faire un GIF pour la première fois tombent sur ce cas : size est réglé sur 1024×1024, le nombre de frames sur seulement 2, et l’API renvoie directement une erreur 400. La raison, c’est que les règles de dimensionnement des GIF diffèrent de celles des images statiques. Cet article présente une méthode de conversion en trois étapes : taille d’une frame → disposition de la mosaïque → contraintes de la mosaïque, pour vous aider à déterminer si un couple size / frame_count donné peut ou non passer la validation.

Il ne s’agit pas d’une simple traduction de la documentation des paramètres. Les valeurs limites citées dans cet article proviennent de mesures réalisées le 2026-11-09 sur la chaîne de relais officielle. Chaque plafond du tableau est accompagné du calcul correspondant, que vous pouvez refaire vous-même.

L’essentiel : après avoir lu cet article, vous saurez choisir une taille de frame adaptée au nombre de frames, éviter les erreurs du type GIF frames exceed the total request pixel budget, et arbitrer entre 512×512, 768×768 et 960×960.

Points clés sur les dimensions GIF de GPT Image 2.6 Sunburst

Commençons par un tableau pour clarifier les règles essentielles de la génération GIF ; nous détaillerons ensuite chaque point.

Mécanisme de génération de la planche mosaïque des GIF GPT Image 2.6

GPT Image 2.6 Sunburst génère un GIF en deux étapes : il dessine d’abord toutes les frames dans une seule grande image selon une grille fixe, puis découpe cette image en frames individuelles et assemble l’animation en fonction de frame_duration_ms. Les limites de taille ne portent donc pas sur une frame isolée, mais sur la longueur d’un côté de cette planche mosaïque, sur le nombre total de pixels et sur le rapport entre côté long et côté court.

La disposition suit des paliers définis par le nombre de frames, et non un arrangement compact basé sur le nombre réel de frames. Par exemple, si frame_count vaut 2, le système utilise quand même une disposition 4×2. L’exemple de la documentation le confirme : une frame unique en 2048×2048 avec seulement 2 frames nécessite déjà une planche de 8192×4096. Pour l’estimation, il faut donc impérativement raisonner en « nombre de cases de la disposition » et non en « nombre réel de frames ».

Comprendre les paramètres de base des GIF GPT Image 2.6

En plus de size, un GIF dispose de deux paramètres dédiés : frame_count contrôle le nombre de frames, frame_duration_ms la durée d’affichage de chaque frame. La durée totale est égale au nombre de frames multiplié par la durée d’une frame. Par exemple, 2 frames × 100 ms donnent une boucle de 0,2 seconde.

Le comportement de frame_count hors plage mérite une attention particulière. Si vous passez 1 ou 17, l’API ne renvoie pas d’erreur 400 : elle ignore frame_count et frame_duration_ms et retombe sur les valeurs par défaut, soit 9 frames et 1,8 seconde. Autrement dit, la requête « réussit », mais le résultat n’est pas celui que vous attendiez. Dans ce cas, il faut vérifier le nombre réel de frames après la génération à l’aide d’un outil ; la méthode est décrite dans la section de prise en main rapide.

GPT Image 2.6 : limites dimensionnelles du GIF Sunburst en détail

Cette section est le cœur de l’article. En croisant les contraintes de la planche et les règles de disposition, on arrive à déduire la taille maximale pour chaque palier de nombre de frames.

Les contraintes de la planche GPT Image 2.6

Les limites hautes sont assez simples à comprendre. La limite de 3840 par côté et celle de 8 294 400 pixels au total sont deux garde-fous indépendants : il faut satisfaire les deux en même temps. Avec peu de frames, c’est souvent la largeur de la planche qui atteint d’abord la limite de côté ; avec beaucoup de frames, c’est généralement le total de pixels qui est atteint en premier.

On oublie souvent la limite basse. La valeur refusée lors du test, 589 824, correspond exactement à 768×768, soit une planche 3×3 de 9 frames en 256×256. La valeur acceptée, 665 856, correspond à 816×816, soit 9 frames en 272×272. On en déduit qu’avec des frames trop petites et une grille à peu de cases, la planche peut aussi être refusée parce qu’elle est trop petite. Par exemple, une grille 4×2 avec des frames en 256×256 ne donne qu’une planche de 1024×512, soit 524 288 pixels au total, sous la limite basse. Donc l’idée de « réduire la taille pour économiser » a elle aussi un plancher.

L’effet du rapport grand côté / petit côté est plus net avec des frames non carrées. Si l’on calcule avec une grille 4×2 et des frames en 16:9, le rapport largeur/hauteur de la planche atteint environ 3,56:1, au-delà de la limite de 3:1 ; avec une grille 3×3 ou 4×4, le rapport redescend. Ce point est déduit des règles : mieux vaut le confirmer par un test avant la mise en production.

GPT Image 2.6 : plafond par image carrée selon le nombre d’images

Les plafonds ci-dessous sont calculés selon la règle « image carrée individuelle + largeur et hauteur multiples de 16 » ; ils sont directement consultables.

Deux détails méritent d’être précisés.

• 10–12 images sont comptées comme 12 cases : la disposition est 4×3 ; même si vous ne demandez que 10 images, la mosaïque occupe quand même les pixels de 12 cases. En test, 12 images en 832² dépassaient de seulement 12 288 pixels et ont été rejetées, ce qui montre que le budget est appliqué strictement.
• 2–8 images sont limitées par un côté : dans cette plage, il reste de la marge sur le total de pixels, mais la largeur de la mosaïque vaut 4 fois la largeur d’une image individuelle ; 960 est donc déjà le plafond. Avec 1024, la largeur de la mosaïque passerait à 4096.

GPT Image 2.6 : comment choisir les tailles courantes

Si l’on traduit les limites ci-dessus en choix concrets, on obtient les conclusions suivantes :

Le 1024×1024 est très courant pour les images statiques, mais totalement inutilisable dans un GIF. Pour 2 à 8 images et 10 à 12 images, la largeur de la mosaïque est de 4096, au-delà de 3840 ; avec 9 images, la mosaïque fait 3072×3072, soit 9,437,184 pixels au total, ce qui dépasse le budget ; pour 13 à 16 images, la largeur de la mosaïque est également de 4096. Donc, quand on passe d’images statiques à un GIF, la première chose à faire est de réduire la taille par défaut.

Si vous avez besoin d’une image au format paysage, je recommande 9 images en 1280×720. La mosaïque adopte alors une disposition 3×3, soit exactement 3840×2160, avec un rapport de 16:9 entre les côtés : les trois contraintes sont respectées.

💡 Conseil de choix : Les limites de taille sont le résultat d’un calcul basé sur des règles ; le budget peut être ajusté côté modèle. Avant la mise en production, je vous conseille de lancer une série de tests aux limites sur APIYI apiyi.com avec quality: "low", afin de confirmer au coût le plus bas les combinaisons de tailles que vous utilisez souvent.

Démarrage rapide avec les GIF Sunburst de GPT Image 2.6

Exemple minimal de GIF avec GPT Image 2.6

Voici l’exemple à faible coût tiré de la documentation de référence : 2 images, 100 ms par image, soit 0,2 seconde au total, pour générer une animation en boucle d’un cercle jaune qui se décale vers la droite puis revient à sa position d’origine. Des champs comme frame_count sont spécifiques aux GIF ; ici, on envoie directement du JSON avec requests, c’est le plus parlant.

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"]))

Quand vous rédigez l’invite, décrivez clairement trois choses : quel est le sujet, comment il se déplace, et comment la boucle fonctionne. Des formulations comme « revient à sa position de départ » ou « seamless loop » permettent de raccorder plus naturellement la première et la dernière image.

Pré-vérification des dimensions GIF et implémentation complète pour GPT Image 2.6

En production, mieux vaut effectuer une pré-vérification locale avant d’envoyer la requête : cela permet d’intercepter en amont les dimensions invalides et d’économiser un aller-retour 400. Le code ci-dessous transforme le tableau de disposition et les contraintes présentés dans cet article en fonctions, tout en restant compatible avec l’interface de génération comme avec l’interface d’édition.

import base64
import requests
from typing import Optional

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.apiyi.com/v1"  # Interface compatible OpenAI d'APIYI

MAX_EDGE = 3840
MAX_PIXELS = 8_294_400   # 3840 x 2160
MIN_PIXELS = 655_360     # Proche de la limite basse mesurée, à titre d'alerte uniquement
MAX_RATIO = 3.0


def sheet_layout(frame_count: int) -> tuple[int, int]:
    """Renvoie la disposition fixe de la planche (colonnes, lignes) selon le nombre de frames"""
    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]:
    """Renvoie une liste de problèmes ; une liste vide signifie que la pré-vérification est passée"""
    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 d'édition : la première image sert de sujet à l'animation
        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))   # Attendu : total de pixels au-dessus du budget
    print(check_gif_size(1280, 720, 9))   # Attendu : [] (validation OK)
    create_gif(
        prompt="让这只猫跳一小段舞，纯色背景，固定镜头，最后一个动作回到起始姿势",
        size="512x512",
        frame_count=16,
        frame_duration_ms=100,
        image_url="https://example.com/cat.png",
        out_path="cat_dance.gif",
    )

Vérifier le nombre réel d’images d’un GIF GPT Image 2.6 avec ffprobe

Lorsque frame_count est hors plage, le système revient silencieusement à 9 images. Il est donc préférable d’ajouter une étape de vérification du nombre réel d’images dans les tâches par lots :

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

L’exemple minimal devrait afficher 2. Si vous obtenez 9, cela signifie que le paramètre du nombre d’images n’a pas été pris en compte : vérifiez que la valeur transmise est bien comprise entre 2 et 16.

Limites fonctionnelles des GIF GPT Image 2.6

Le mode GIF ne prend pas en charge les fonctionnalités suivantes, ne les incluez pas dans vos requêtes :

• stream pour la sortie en flux et l’aperçu progressif des images partielles
• la personnalisation de output_compression
• prompt_rewriter

De plus, frame_count et frame_duration_ms ne concernent que les GIF : ne les transmettez pas aux requêtes PNG, JPEG, WebP ou SVG.

🚀 Démarrage rapide : après vous être inscrit sur APIYI apiyi.com, profitez du crédit d’essai gratuit réservé aux nouveaux utilisateurs. Commencez par valider tout le processus avec du 512×512, 2 images et quality: "low", puis augmentez progressivement le nombre d’images et la taille. La plateforme propose une interface compatible OpenAI : une seule clé API suffit pour appeler GPT Image et d’autres modèles majeurs.

FAQ – questions fréquentes

Points clés sur les dimensions des GIF Sunburst de GPT Image 2.6

• size correspond à la taille d’une seule frame : la limite s’applique à la mosaïque partagée par toutes les frames, pas à une frame isolée
• La disposition est fixée par paliers : quatre dispositions 4×2, 3×3, 4×3 et 4×4, correspondant respectivement à 2–8, 9, 10–12 et 13–16 frames
• Trois contraintes strictes : côté de la mosaïque ≤ 3840, pixels totaux ≤ 8,294,400, rapport grand côté / petit côté ≤ 3:1
• La taille la plus sûre est 512×512 : utilisable de 2 à 16 frames ; 768² plafonne à 12 frames, 960² à 9 frames
• 1024² est totalement inutilisable : quand vous reprenez les paramètres d’une image statique, il faut d’abord réduire la taille
• Un nombre de frames hors limites déclenche un repli silencieux : mieux vaut valider la plage côté client et vérifier le nombre de frames avec ffprobe après la génération
• Validation à moindre coût : lancez vos tests de limites sur APIYI apiyi.com avec quality: "low", c’est le tarif le plus bas

Résumé

La règle des dimensions pour générer un GIF avec GPT Image 2.6 Sunburst tient en trois étapes de calcul :

1. Choisir la disposition : d’après frame_count, on retombe sur la disposition 4×2, 3×3, 4×3 ou 4×4 correspondante
2. Calculer la mosaïque : on multiplie la largeur et la hauteur d’une frame par le nombre de colonnes et de lignes de la disposition pour obtenir la largeur, la hauteur et le total de pixels de la mosaïque
3. Vérifier : on contrôle le côté, les bornes de pixels totaux et le rapport grand côté / petit côté, puis on confirme que largeur et hauteur sont des multiples de 16

Au quotidien, 512×512 reste la valeur par défaut la plus compatible ; si vous avez besoin d’une grande image, 9 frames en 960×960 ou 1280×720 permettent d’exploiter tout le budget. En intégrant la fonction de pré-vérification de cet article dans votre code métier, la plupart des erreurs 400 seront détectées en amont, en local.

Pour valider rapidement vos combinaisons de dimensions, je vous recommande de passer par APIYI apiyi.com : la plateforme offre un quota de test gratuit et une interface unifiée compatible OpenAI, idéale pour boucler les tests de limites avant l’intégration définitive.

📚 Références

1. Centre de documentation APIYI – GPT Image 2.6 : génération d’animations en boucle GIF : description des paramètres officiels et des limites constatées en pratique
2. Lien : docs.apiyi.com/api-capabilities/gpt-image-2/gpt-image-2-6

3. Description : présente la plage des paramètres GIF, les contraintes d’assemblage des images, des exemples d’erreurs et l’utilisation de l’interface d’édition

4. Documentation officielle FFmpeg – ffprobe : outil de consultation des métadonnées audio-vidéo et GIF

5. Lien : ffmpeg.org/ffprobe.html
6. Description : permet de vérifier le nombre réel d’images du GIF généré ainsi que la durée de chaque image

Auteur : équipe technique APIYI
Échanges techniques : si vous rencontrez des difficultés lors de la configuration des dimensions d’un GIF, n’hésitez pas à nous contacter via la page d’accueil du site officiel APIYI pour bénéficier d’un accompagnement supplémentaire à l’intégration.

Articles connexes

• Décryptage des limites cachées de l’API GPT Image 2.6 : 5 types de limites de combinaison pour les GIF, les SVG et la retouche locale: Décryptage des limites des points d’accès, des conflits de paramètres et des précautions de migration pour les GIF, les SVG et l’édition locale de markup dans l’API GPT Image 2.6, afin d’éviter aux développeurs de croire qu’il suffit de changer le nom du modèle.
• Décryptage du paramètre Complexity de GPT Image 2.6 : comment les 3 niveaux de « profondeur de réflexion » modifient la composition des images générées: Décryptage du nouveau paramètre Complexity de GPT Image 2.6 : influence des niveaux low/medium/high sur la planification des scènes, différence avec Quality et méthode pour les tester équitablement et choisir un niveau dans l’API.
• ChatGPT Images 2.6 est lancé : GIF et images de référence disponibles, génération 50 % plus rapide, comment utiliser GPT-Image-2.6 Flare et Sunburst ?: Décryptage de ChatGPT Images 2.6, publié le 4 novembre 2026 : GIF, images de référence réutilisables, édition par annotations markup et export SVG, choix entre Flare et Sunburst, coûts des cinq niveaux en 1024×1024 et distinction entre déclarations officielles, classements tiers et inconnues.
• GPT-Image-2.6 vs Nano Banana 2.1 : quelles différences pour les GIF, la 4K et les prix, et lequel choisir ?: Comparez GPT-Image-2.6 et Nano Banana 2.1 selon les livrables : images animées et vectorielles, 4K et multiples images de référence, deux méthodes de benchmark, deux modes de facturation et un tableau de sélection pour trois types de tâches.
• Qu’est-ce que Grok Imagine a retiré aujourd’hui ? Les anciens modèles sont-ils encore utilisables ? Les 4 points clés pour comprendre la migration vers la version 2.0: Seul l’identifiant grok-imagine-image-quality sera retiré le 2 novembre 2026, et non l’ensemble de Grok Imagine ; cet article explique les conséquences, l’évolution des prix, les paramètres de qualité et la migration vers la version 2.0.
• Oh là là ! Krea 3, vas-tu anéantir Nano Banana ?: Découvrez les performances de Krea 3 pour les visuels publicitaires de marque en 5 étapes avec Ad Studio, du site officiel au kit de marque puis à 12 publicités statiques, avec des exemples officiels, un tableau des coûts et 7 pièges à éviter.