OpenAI Images 2.6 : plus rapide, avec prise en charge des GIF

Jusqu'à la semaine dernière, obtenir une image animée depuis ChatGPT supposait de demander une feuille de sprites, de la télécharger, puis d'assembler vous-même les images dans un autre outil. Je l'ai fait plus souvent que je ne préfèrerais l'avouer. 

Le 4 novembre, OpenAI a lancé Images 2.6, et désormais, vous tapez "make a gif of a cat dancing" et vous récupérez un GIF en boucle.

Les GIF font la une, mais ce n'est pas tout. OpenAI annonce des images générées 50 % plus vite, des retouches qui préservent mieux les personnages et les produits, et une API déclinée en deux modèles aux usages différents. 

Dans cet article, je vous présente Images 2.6, ce qui change, et comment créer un GIF dans ChatGPT comme via l'API. 

Quoi de neuf dans OpenAI Images 2.6 ?

OpenAI Images 2.6 est la mise à jour d'images d'OpenAI du 4 novembre 2026 pour ChatGPT, Codex et l'API. Les principaux changements :

• GIF animés : Transformez un prompt, une photo ou un croquis en un court GIF en boucle, puis ajustez sa vitesse ou éditez des images individuelles.

• Génération plus rapide : OpenAI affirme que les images sont générées 50 % plus vite qu'Images 2.5.

• Retouches plus stables : Les personnages, produits et éléments de marque dérivent moins au fil des itérations.

• Deux modèles API : utilisez gpt-image-2.6-flare pour la vitesse et gpt-image-2.6-sunburst pour le détail.

• Petites améliorations : export en SVG, retouches guidées par annotations via l'API, référence d'images enregistrées et nouveau paramètre complexity.

Disponible pour tous les forfaits ChatGPT, y compris Free, même si la création de GIF est déployée progressivement.

Qu'est-ce qu'OpenAI Images 2.6 ?

OpenAI Images 2.6 est la version de génération et d'édition d'images publiée par OpenAI le 4 novembre 2026. Elle est disponible en tant qu'outil image dans ChatGPT et Codex, ainsi que sous la forme de deux modèles distincts dans l'OpenAI API.

Dans ChatGPT, vous ne pouvez pas choisir un modèle ni basculer entre Flare et Sunburst : vous saisissez une demande et le GIF est généré. Avec l'API, en revanche, vous pouvez choisir explicitement l'un des deux modèles et régler vous-même des paramètres comme la qualité et la complexité.

Les deux modèles API coûtent le même prix par token, et ces tarifs correspondent à ceux des modèles Images 2.5. Le choix entre Flare et Sunburst oppose donc vitesse et détail, pas le prix. Le coût par image varie encore car des réglages de qualité supérieure consomment plus de jetons de sortie.

Imaginons qu'une marque de café veuille un court GIF en boucle de sa mascotte, une tasse de café cartoon, qui fait coucou.

• Dans ChatGPT (une marketeuse) : elle tape « Make a looping GIF of our coffee-cup mascot waving hello. » ChatGPT choisit le modèle et génère le GIF. Si c'est trop lent, elle tape « make it faster » dans le chat. Elle ne modifie aucun réglage et ne paie rien de plus que son forfait ChatGPT.

• Avec l'API (un développeur) : il ajoute un bouton « Make a GIF » à l'application de la marque, donc il écrit le code. Il sélectionne gpt-image-2.6-flare car c'est le modèle le plus rapide, règle output_format: "gif" et choisit le nombre d'images et la qualité. Chaque GIF est facturé en jetons : une qualité plus élevée coûte plus cher par image.

Quoi de neuf dans OpenAI Images 2.6 ?

Images 2.6 apporte les GIF animés, une génération plus rapide, des retouches plus régulières sur plusieurs tours, et de meilleures mises en page pour les visuels pros. 

OpenAI Images 2.6 est-il vraiment plus rapide ?

OpenAI affirme qu'Images 2.6 génère des images 50 % plus vite qu'Images 2.5, et que gpt-image-2.6-flare peut produire une image de faible qualité en six secondes seulement. C'est ambitieux, et l'annonce n'explique pas la métrique utilisée. J'ai donc testé moi-même.

J'ai donné à Flare et Sunburst le même prompt, « A ceramic coffee mug on a wooden desk, morning light, product photo, » en 1024x1024 avec la complexité sur low. Flare a tourné en low et medium (puisque low correspond à l'allégation des six secondes), et Sunburst en medium. 

Chaque configuration a tourné cinq fois, et j'ai conservé la médiane, car une réponse anormalement lente peut fausser une moyenne. Puis j'ai répété tout le test, la vitesse réseau variant d'un run à l'autre, afin d'éviter qu'un après-midi chanceux (ou non) ne décide du résultat.

Si vous voulez comparer mes chiffres aux vôtres, voici le script exécuté dans Google Colab :

import statistics
import time

from openai import OpenAI

# Reads OPENAI_API_KEY from your environment
client = OpenAI()
prompt = "A ceramic coffee mug on a wooden desk, morning light, product photo."

# Each setup: (model, quality)
setups = [
    ("gpt-image-2.6-flare", "low"),
    ("gpt-image-2.6-flare", "medium"),
    ("gpt-image-2.6-sunburst", "medium"),
]

for model, quality in setups:
    times = []
    for _ in range(5):
        start = time.perf_counter()
        client.images.generate(
            model=model,
            prompt=prompt,
            size="1024x1024",
            quality=quality,
            extra_body={"complexity": "low"},  # skip extra planning for a simple scene
        )
        times.append(time.perf_counter() - start)
    # The median ignores one unusually slow or fast request
    print(model, quality, round(statistics.median(times), 1), "s")
Propulsé par

Voici ce que j'ai obtenu :

Flare n'est jamais descendu sous les six secondes annoncées par OpenAI ; ma meilleure médiane a été 6,9. Ce n'est pas vraiment une promesse trahie, car « jusqu' » décrit un cas idéal, pas la tendance. Lors du second run, low et medium se sont même inversés, Flare en medium finissant plus vite qu'en low. 

À cette taille, le réglage de qualité change très peu la vitesse de Flare, et le bruit réseau pèse plus lourd que la différence.

Sunburst est le plus lent, et cela s'est confirmé : 14,5 et 15,8 secondes, soit environ deux fois Flare.

Souvenez-vous du paramètre de complexité évoqué plus haut. 

Il contrôle le niveau de planification avant rendu, et sa valeur par défaut est high. Le chiffre des six secondes suppose presque sûrement une complexité low, d'où mon choix pour le test. Si vous ne le réglez pas, vous payez du temps de planification pour une photo de tasse qui n'en a pas besoin.

Plus rapide ne veut pas dire moins cher. Une image 1024x1024 en faible qualité utilise 823 jetons de sortie en 2.6 contre 196 en 2.5. Le prix par jeton n'a pas changé : à $30 pour 1 M de jetons de sortie, cela fait environ $0,025 par image au lieu de $0,006. Faible par image, pas négligeable sur 10 000.

L'édition d'images est-elle vraiment plus cohérente ?

D'après OpenAI, Images 2.6 préserve davantage les parties non modifiées lors d'une retouche, surtout au fil de plusieurs itérations. Sunburst est le modèle recommandé ici car, en qualité moyenne ou élevée, il maintient mieux les détails d'une étape à l'autre.

Ce que couvre la notion de « cohérence » en pratique :

Pour tester, j'ai généré un flacon de parfum avec gpt-image-2.6-sunburst en qualité moyenne, puis j'ai uniquement changé l'arrière-plan trois fois : une plage, un ciel nocturne et une étagère de cuisine. 

Chaque retouche est repartie du résultat précédent, pas de l'original, afin que tout éventuel « drift » s'accumule. Chaque prompt de retouche se terminait ainsi : « Keep the bottle, label, cap, and lighting on the bottle exactly the same. »

Voici l'original à côté de la troisième retouche :

L'original : un flacon vert à bouchon doré sur un plan de travail en marbre. Image d’auteur.

Après trois tours, le flacon est quasiment intact. L'étiquette indique toujours « MOSS No. 3 » avec la même typo serif et bordure dorée, le bouchon, la forme carrée et même le fin tube à l'intérieur du verre correspondent à l'original.

Ce qui a changé, c'est tout autour :

• L'arrière-plan s'est propagé : j'ai demandé un ciel nocturne au tour 2 et j'ai obtenu la plage du tour 1 de nuit, palmier compris. Comme chaque retouche repart de l'image précédente, Sunburst a traité la plage comme un élément à conserver, et seule la cuisine au tour 3 a enfin tout effacé. Le marbre a survécu aux trois retouches aussi, sans que je le demande. Logique : c'est le support du flacon.
• L'éclairage est resté exactement tel quel, et c'était le problème : Sunburst a pris ma demande au pied de la lettre : la bouteille est éclairée comme en plein après-midi sous la pleine lune, avec la même ombre marquée dans chaque scène, donnant un effet « collé ».

Pour des packshots, c'est toutefois la cohérence attendue. Il suffit de ne pas exiger de conserver l'éclairage si la scène doit changer de lumière.

Les visuels professionnels (affiches, etc.) sont-ils meilleurs ?

Pour des mises en page comme des affiches ou des visuels produits, OpenAI recommande Flare, pas Sunburst. Flare est censé placer le texte, les images et les espacements avec plus d'intention, tandis que Sunburst vise la finesse de détail et la cohérence. 

Cela m'a un peu surpris. On s'attendrait à ce que le modèle le plus rapide soit le moins soigné, alors je les ai comparés sur une affiche.

J'ai donné aux deux modèles le même prompt en qualité moyenne et en format portrait 1024x1536 : « A poster for a Saturday farmers market. Title: ‘Riverside Market’. Subtitle: ‘Every Saturday, 8 AM to 1 PM’. Illustrated vegetables at the bottom, clean sans-serif type. »

Résultats ci-dessous : Flare à gauche, Sunburst à droite :

Comparaison d'affiches Flare vs Sunburst. Image d’auteur.

Chaque mot est sorti correctement dans les deux cas, ce que je n'attendais pas. Ils ont aussi pris « Riverside » au pied de la lettre et dessiné une rivière et un pont derrière les légumes, sans que je le demande.

La différence tient à l'ampleur des ajouts : 

• Flare est resté simple : un titre immense, le sous-titre dans un cartouche vert, puis les légumes. Lisible à plusieurs mètres. 

Sunburst a bâti une scène complète, avec étal, tournesols, arbre et ruban jaune, pour un rendu plus illustré.

Sunburst a mis trois fois plus de temps. Pour une affiche, où l'on doit lire le titre d'un coup d'œil, je choisirais la version de Flare.

Que faire avec la génération de GIF animés ?

Images 2.6 transforme un prompt texte, une photo téléversée ou un croquis en un court GIF en boucle. Dans ChatGPT, vous pouvez ensuite changer la vitesse de lecture et éditer des images individuelles sans quitter la conversation. Avant cette version, ChatGPT ne pouvait pas créer un GIF en une étape.

Ce à quoi c'est utile :

• Personnages animés : une mascotte ou un gribouillis qui salue, cligne des yeux ou saute.
• GIF de réaction et social media : de courtes boucles pour vos posts et réponses.
• Animations produit : une photo packshot devient une boucle qui capte l'attention dans un flux.
• Storyboards : tester l'animation d'un personnage avant d'investir dans la vidéo. OpenAI précise bien qu'il ne s'agit pas d'un générateur vidéo : un GIF, ce sont quelques images en boucle, pas un clip.

Pas besoin d'un design finalisé. Dessinez un personnage à main levée, téléversez-le et demandez-lui de faire coucou. Je vous montre tout le flux de travail dans la section suivante.

Quoi d'autre change ?

Quelques mises à jour secondaires, réparties entre l'API et ChatGPT :

• Export SVG (API uniquement) : définissez output_format: "svg" pour obtenir des fichiers vectoriels pour le web, les applis ou l'impression.
• Le paramètre complexity (API) : comme cité dans le test de vitesse, accepte "low", "medium" ou "high". Utilisez low pour des retouches simples (remplacement d'arrière-plan) et réservez high aux scènes chargées avec beaucoup de contraintes. Augmenter la qualité ne résoudra pas une scène surchargée ; augmenter la complexité, peut-être.
• Images de référence enregistrées (ChatGPT) : téléversez une photo de vous, de votre animal ou d'une mascotte une seule fois ; ChatGPT la conserve. Dans une autre conversation, demandez simplement « my cat in a spacesuit » sans renvoyer la photo : c'est le même chat qui apparaîtra.

• Retouches guidées par annotations (ChatGPT et API) : entourez la zone à modifier et indiquez le changement, par exemple encercler un vase et écrire « make it blue. » ChatGPT le proposait déjà ; Images 2.6 l'apporte à l'API.

Comment créer des GIF avec OpenAI Images 2.6

Pour créer un GIF, demandez-le dans ChatGPT, ou appelez l'API Images avec output_format: "gif". ChatGPT est plus rapide pour un besoin ponctuel, mais l'API vous donne la main sur le nombre d'images et le minutage : crucial si vous produisez plus que quelques GIF.

Comment faire un GIF dans ChatGPT

Ouvrez une nouvelle discussion et décrivez le GIF : le sujet, le mouvement, et le fait qu'il doit boucler. Voici ce que j'ai demandé : « Make a GIF of a small orange robot waving, then returning to its starting pose. Keep the background plain and the camera still. »

ChatGPT avec Images 2.6 génère un robot orange. GIF d’auteur.

Vous pouvez aussi partir d'un contenu existant. Téléversez une photo ou un croquis, puis indiquez ce qui doit bouger et ce qui doit rester fixe.

J'ai essayé avec un dessin d'enfant représentant un oiseau :

Un croquis d'oiseau. Image d’auteur.

Mon prompt : « Turn this child’s drawing into a looping GIF. Keep the hand-drawn style. Make the bird hop once and flap its wing, then return to its starting pose. Keep the background plain white and the camera still. »

Le GIF généré par ChatGPT à partir d'un croquis. GIF d’auteur.

ChatGPT a renvoyé une boucle de 9 images à 180 ms par image, soit environ 1,6 seconde, dans un fichier de 183 Ko. Il a gardé le style griffonné, alors que je m'attendais à ce qu'il le « corrige ». L'oiseau s'accroupit, saute pattes rentrées, puis atterrit.

Mon détail préféré n'était pas demandé : l'aile tracée en un seul trait devient une vraie aile pendant le battement, puis se replie en une courbe à l'atterrissage. ChatGPT a même ajouté des traits de mouvement, comme le ferait un enfant.

Les trois dernières images sont quasi identiques, ce qui marque une petite pause avant le saut suivant. Cela masque bien le point de bouclage, même si, en regardant de près, l'oiseau se décale légèrement au redémarrage.

Une fois le GIF prêt, vous pouvez le ralentir, l'accélérer ou corriger des images individuelles. Pas besoin d'accéder aux contrôles : des demandes en langage naturel fonctionnent, par exemple « Make the transition from the last frame back to the first smoother. »

Comment faire un GIF avec l'OpenAI API

Envoyez une requête au point d'accès de génération d'images avec output_format réglé sur "gif". Deux réglages spécifiques aux GIF :

Avec les défauts, vous obtenez 9 images à 200 ms, soit une boucle de 1,8 seconde.

J'ai exécuté le code ci-dessous dans Google Colab avec la version 3.46 du package openai, et il a fonctionné tel quel. L'API a respecté tous les réglages, jusqu'au format 512x512.

import base64

from openai import OpenAI

# Reads OPENAI_API_KEY from your environment
client = OpenAI()

result = client.images.generate(
    model="gpt-image-2.6-flare",  # Flare: faster; switch to sunburst for detail
    prompt=(
        "A small orange robot waves, blinks, and returns to its starting pose. "
        "Plain white background, fixed camera, seamless loop."
    ),
    output_format="gif",
    frame_count=9,  # 9 frames x 200 ms = a 1.8-second loop
    frame_duration_ms=200,
    size="512x512",  # smaller frames keep the file size down
    quality="low",
    complexity="low",  # a simple motion doesn't need extra planning
)

# The GIF comes back as base64; decode it and save it to disk
gif_bytes = base64.b64decode(result.data[0].b64_json)
with open("robot.gif", "wb") as f:
    f.write(gif_bytes)
Propulsé par

L'API image-2.6-flare génère un robot orange qui salue en boucle. GIF d’auteur.

Comparez-le au robot de ChatGPT. Les deux montrent un robot orange qui salue, mais celui-ci est plus brut car le code règle quality="low" pour gagner en temps et en coût. La surface paraît rayée, de petites pièces (antennes) bougent entre les images, et une image transforme le salut en pouce levé. Low convient pour un GIF de réaction rapide dans un chat. Pour tout usage de marque, préférez "medium" ou "high".

Le fichier pèse 429 Ko, proche du plafond de 500 Ko fixé par de nombreux sites.

Avant d'aller plus loin, deux limites :

• Pas de streaming : les images partielles et output_compression ne fonctionnent pas non plus avec la sortie GIF.

• Un budget de pixels : le nombre d'images, la taille de chaque image et n doivent tenir dans un total. Si une requête échoue, réduisez l'un des trois.

Comment obtenir une boucle fluide ?

Dans votre prompt, demandez un mouvement qui finit où il commence, et précisez ce qui doit rester fixe. Si la dernière image ne correspond pas à la première, un à-coup sera visible à chaque redémarrage. Ralentir avec frame_duration_ms ne masquera pas ce saut. Demandez plutôt à revenir à la pose initiale, comme pour le robot et l'oiseau.

En pratique :

• Choisissez une action courte et réversible (salut, clin d'œil).
• Gardez caméra, arrière-plan et échelle fixes.
• Évitez le texte dans l'image.
• Regardez plusieurs boucles complètes et vérifiez les images intermédiaires, pas seulement la première et la dernière. C'est au milieu que mon robot API a glissé un pouce levé.

Contrôlez le poids du fichier avant de publier un GIF sur un site. Mon robot 512x512 en 9 images faisait déjà 429 Ko ; en 1024x1024 et 16 images, vous dépasserez largement 500 Ko.

Conclusion

Si vous créez des GIF pour les réseaux sociaux, des mascottes ou des storyboards, Images 2.6 change la donne : plus besoin d'un outil séparé pour animer vos images.

En revanche, si les GIF ne vous intéressent pas et que vous cherchez un outil pour des images fixes, notre guide des meilleurs générateurs d'images IA gratuits compare d'excellentes options. Pour voir comment Google gère les mêmes défis d'édition, lisez notre guide Nano Banana 2.