OpenAI Images 2.6: Nu snabbare, med stöd för GIF:ar

Fram till förra veckan innebar en rörlig bild ur ChatGPT att du bad om en spritesheet, laddade ner den och satte ihop bildrutorna själv i något annat verktyg. Jag gjorde detta oftare än jag vill erkänna. 

Den 4 november släppte OpenAI Images 2.6, och nu skriver du "make a gif of a cat dancing" och får en loopande GIF tillbaka.

GIF:ar är rubriken, men inte hela releasen. OpenAI säger att bilder nu genereras 50 % snabbare, redigeringar håller kvar karaktärer och produkter bättre, och API:t delas i två modeller med olika jobb. 

I den här artikeln går jag igenom vad Images 2.6 är, vad som ändrats och hur du gör en GIF i både ChatGPT och med API:t. 

Vad är nytt i OpenAI Images 2.6?

OpenAI Images 2.6 är OpenAIs bilduppdatering den 4 november 2026 för ChatGPT, Codex och API:t. De största förändringarna är:

• Animerade GIF:ar: Förvandla en prompt, ett foto eller en skiss till en kort loopande GIF, justera sedan hastigheten eller redigera enskilda bildrutor.

• Snabbare generering: OpenAI hävdar att bilder genereras 50 % snabbare än Images 2.5.

• Stadigare redigeringar: Karaktärer, produkter och varumärkesdetaljer drivar mindre mellan redigeringsrundor.

• Två API-modeller: Använd gpt-image-2.6-flare för hastighet och gpt-image-2.6-sunburst för detaljer.

• Mindre tillägg: Exportera bilder i SVG, gör märkstyrsda redigeringar i API:t, referera till sparade bilder och använd dess complexity-parameter.

Det är tillgängligt på varje ChatGPT-plan, inklusive Free, även om GIF-skapande rullas ut till konton stegvis.

Vad är OpenAI Images 2.6?

OpenAI Images 2.6 är releasen för bildgenerering och -redigering som OpenAI släppte den 4 november 2026. Den finns som bildverktyg i ChatGPT och Codex samt som två separata modeller i OpenAI API.

I ChatGPT kan du inte välja modell eller växla mellan dess modeller, Flare och Sunburst; du skriver bara en begäran, och den genererar en GIF. Men med API:t kan du välja mellan två modeller vid namn och styra inställningar som kvalitet och komplexitet själv.

Båda API-modellerna kostar samma per token, och dessa priser matchar Images 2.5-modellerna. Så valet mellan Flare och Sunburst handlar om hastighet kontra detalj, inte pris. Kostnaden per bild varierar fortfarande eftersom högre kvalitetsinställningar använder fler utgående token.

Anta att ett kaffemärke vill ha en kort loopande GIF av sin maskot, en tecknad kaffekopp, som vinkar hej.

• I ChatGPT (en marknadsförare): Hon skriver ”Make a looping GIF of our coffee-cup mascot waving hello.” ChatGPT väljer modell och gör GIF:en. Om den är för långsam skriver hon ”make it faster” i chatten. Hon ändrar inga inställningar och betalar inget utöver sin ChatGPT-plan.

• Med API:t (en utvecklare): Han lägger till en ”Make a GIF”-knapp i varumärkets app, så han skriver koden själv. Han väljer gpt-image-2.6-flare eftersom det är den snabbare modellen, sätter output_format: "gif" och väljer antal bildrutor och kvalitet. Varje GIF debiteras per token, så högre kvalitet kostar mer per bild.

Vad är nytt i OpenAI Images 2.6?

Images 2.6 lägger till animerade GIF:ar, snabbare generering, stabilare flerrundorsredigeringar och bättre layouter för professionella visuella material. 

Är OpenAI Images 2.6 verkligen snabbare?

OpenAI säger att Images 2.6 genererar bilder 50 % snabbare än Images 2.5, och att gpt-image-2.6-flare kan returnera en lågkvalitativ bild på så lite som sex sekunder. Det är ett djärvt påstående, och tillkännagivandet förklarar inte hur det mättes. Så jag testade själv.

Jag gav Flare och Sunburst samma prompt, ”A ceramic coffee mug on a wooden desk, morning light, product photo,” i 1024x1024 med komplexitet satt till låg. Flare kördes på både låg och medel kvalitet, eftersom låg är inställningen bakom OpenAIs sexsekunderspåstående, och Sunburst kördes på medel. 

Varje upplägg kördes fem gånger, och jag behöll medianen, eftersom ett långsamt svar kan förstöra ett medelvärde. Sedan upprepade jag hela testet, eftersom nätverkshastigheten varierar mellan körningar och jag inte ville att en tursam (eller otursam) eftermiddag skulle avgöra resultatet.

Om du vill jämföra mina siffror med dina egna, här är skriptet jag körde i 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")
Drivs av

Här är vad jag fick:

Flare kommer aldrig under OpenAIs sex sekunder; min bästa median var 6,9. Det är inte riktigt ett brutet löfte, eftersom ”as little as” beskriver bästa fallet, inte det typiska. Den andra körningen vände också låg och medel kvalitet, där Flare på medel blev klar snabbare än på låg. 

I den här storleken påverkar kvalitetsinställningen knappt Flares hastighet, och nätverksbrus är större än skillnaden.

Sunburst är den långsamma, och det stod sig båda gångerna: 14,5 och 15,8 sekunder, ungefär dubbelt så lång tid som Flare.

Minns komplexitetsinställningen från tidigare? 

Den styr hur mycket modellen planerar innan rendering, och standard är hög. OpenAIs sexsekunderssiffra förutsätter nästan säkert att den är satt till låg, vilket är varför jag testade så. Lämnar du den oinställd betalar du för planeringstid på en mugg-bild som inte behöver det.

Snabbare betyder dock inte billigare. En lågkvalitativ 1024x1024-bild använder 823 utgående token i 2.6 jämfört med 196 i 2.5. Priset per token ändrades inte, så med $30 per 1M utgående token blir det ungefär $0,025 per bild i stället för $0,006. Litet per bild, inte litet över 10 000 av dem.

Hur mycket mer konsekvent är bildredigering?

Enligt OpenAI lämnar Images 2.6 mer av en bild oförändrad när du redigerar en del av den, särskilt över flera redigeringsrundor. Sunburst är modellen de rekommenderar för detta eftersom den, på medel eller hög kvalitet, håller detaljer stadigare från en redigering till nästa.

Här är vad ”konsekvent” täcker i praktiken:

För att testa detta genererade jag en parfymflaska med gpt-image-2.6-sunburst på medel kvalitet och bytte sedan bara bakgrunden tre gånger: en strand, en natthimmel och en kökshylla. 

Varje redigering utgick från föregående resultat, inte originalet, så all drift skulle staplas på varandra. Varje redigeringsprompt slutade på samma sätt: ”Behåll flaskan, etiketten, korken och belysningen på flaskan exakt likadant.”

Här är originalet bredvid den tredje redigeringen:

Originalet: en grön flaska med guldkork på en marmorbänk. Bild av författaren.

Efter tre rundor kom flaskan igenom nästan orörd. Etiketten står fortfarande ”MOSS No. 3” i samma seriftyp och guldram, och korken, den fyrkantiga formen och till och med det tunna röret inuti glaset matchar originalet.

Det som ändrades var allt runt omkring:

• Bakgrunden följde med: Jag bad om en natthimmel i runda 2 och fick rundas 1 strand på natten, palm inkluderad. Eftersom varje redigering bygger på den senaste bilden behandlade Sunburst stranden som något att behålla, och först köket i runda 3 rensade den. Marmorbänken överlevde också alla tre redigeringarna, vilket jag inte bad om. Rättvist nog; det är det flaskan står på.
• Belysningen förblev exakt som jag bad, och det var problemet: Sunburst tog min prompt bokstavligt, så flaskan är belyst som en solig eftermiddag under fullmåne, med samma hårda skugga i varje scen så att den ser inklistrad ut.

För produktbilder är detta ändå den konsekvens folk har efterfrågat. Säg bara inte åt den att behålla belysningen när scenens ljus borde ändras.

Är professionella visuella material som affischer bättre?

För layoutjobb som affischer och produktbilder föreslår OpenAI Flare, inte Sunburst. Flare ska placera text, bilder och mellanrum mer avsiktligt, medan Sunburst är tänkt för fin detalj och konsekvens. 

Det förvånade mig lite. Man kunde tro att den snabbare modellen skulle vara slarvigare, så jag satte båda på en affisch för att se.

Jag gav båda modellerna samma prompt på medel kvalitet och ett stående 1024x1536-format: ”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.”

Se resultaten nedan: Flare till vänster, Sunburst till höger:

Jämförelse av affischer från Flare och Sunburst. Bild av författaren.

Varje ord blev rätt på båda, vilket jag inte väntade mig av någon. De tolkade också ”Riverside” bokstavligt och målade en flod med en bro bakom grönsakerna, trots att jag aldrig bad om en.

Skillnaden ligger i hur mycket var och en lägger till: 

• Flare höll det enkelt med en enorm titel, undertiteln i en grön pillerform och sedan grönsaker. Du skulle kunna läsa den tvärs över gatan. 

Sunburst byggde en hel scen, med marknadsstånd, solrosor, ett träd och ett gult band, och den ser mer ut som en färdig illustration.

Sunburst tog tre gånger så lång tid. För en affisch, där folk behöver läsa titeln och gå vidare, skulle jag välja Flares version.

Vad kan du göra med generering av animerade GIF:ar?

Images 2.6 förvandlar en textprompt, en uppladdad bild eller en grov skiss till en kort loopande GIF. I ChatGPT kan du sedan ändra uppspelningshastigheten och redigera enskilda bildrutor utan att lämna chatten. Innan den här releasen kunde inte ChatGPT göra en GIF i ett steg.

Vad det är bra för:

• Animerade karaktärer: En maskot eller kludd som vinkar, blinkar eller hoppar.
• Reaktions-GIF:ar och socialt innehåll: Korta loopar för inlägg och svar.
• Produktanimationer: En stillastående produktbild blir en loop som fångar uppmärksamhet i flödet.
• Storyboardar: Testa hur en figur rör sig innan du betalar för videoproduktion. OpenAI var tydlig med att detta inte är en videogenerator; en GIF är några bildrutor på repeat, inte ett klipp.

Du behöver inte en färdig design heller. Rita en grov figur, ladda upp den och be den vinka. Jag går igenom hela arbetsflödet i nästa avsnitt.

Vad mer ändrades?

Några mindre uppdateringar, uppdelade mellan API:t och ChatGPT:

• SVG-export (endast API): Sätt output_format: "svg" för att få vektorfiler för webbplatser, appar eller tryck.
• Parametern complexity (API): Som jag nämnde i hastighetstestet accepterar den "low", "medium" eller "high". Använd låg för enkla redigeringar som bakgrundsbyten, och spara hög till trånga scener med många begränsningar. Att höja kvaliteten löser inte en trång scen; att höja komplexiteten kan göra det.
• Sparade referensbilder (ChatGPT): Ladda upp ett foto av dig själv, ditt husdjur eller en maskot en gång, så sparar ChatGPT det. I en senare konversation ber du bara om ”min katt i en rymddräkt” utan att ladda upp fotot igen, och samma katt dyker upp varje gång.

• Märkstyrsda redigeringar (ChatGPT och API): Ring in delen du vill ändra och säg vad som ska ändras, som att ringa in en vas och skriva ”gör den blå.” ChatGPT hade redan detta; Images 2.6 tar det till API:t.

Hur du skapar GIF:ar med OpenAI Images 2.6

För att göra en GIF, be om en i ChatGPT, eller anropa Images API med output_format: "gif". ChatGPT är snabbare för en engångsgrej, men API:t ger dig kontroll över antal bildrutor och timing, vilket är ganska viktigt om du gör fler än ett fåtal GIF:ar.

Så gör du en GIF i ChatGPT

Öppna en ny chatt och beskriv GIF:en: motivet, rörelsen och att den ska loopa. Här är vad jag bad om: ”Make a GIF of a small orange robot waving, then returning to its starting pose. Keep the background plain and the camera still.”

ChatGPT med Images 2.6 genererar en orange robot. GIF av författaren.

Du kan också börja från något du redan har. Ladda upp ett foto eller en grov skiss, säg sedan vad som ska röra sig och vad som måste vara stilla.

Jag testade detta med en barns teckning av en fågel:

En grov teckning av en fågel. Bild av författaren.

Min 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.”

GIF:en som ChatGPT gjorde från en grov teckning. GIF av författaren.

ChatGPT returnerade en 9-bildruters loop på 180 ms per ruta, cirka 1,6 sekunder, i en fil på 183 kB. Den behöll den slarviga stilen, som jag halvt väntade mig att den skulle ”fixa”. Fågeln hukar, hoppar med benen indragna och landar.

Min favoritdetalj är en jag aldrig bad om. Vingen som är ett enda streck växer till en riktig vinge för fladdret, och viks sedan tillbaka till en kurva när fågeln landar. ChatGPT lade till och med till små rörelselinjer, som ett barn skulle göra.

De sista tre rutorna är nästan identiska, så fågeln pausar före nästa hopp. Den pausen döljer looppunkten väl, även om du ser noga skiftar fågeln lite när den startar om.

När en GIF är klar kan du sänka farten, öka farten eller fixa enskilda rutor. Du behöver inte heller kontrollerna för detta. Vanliga formuleringar fungerar, såsom ”Make the transition from the last frame back to the first smoother.”

Så gör du en GIF med OpenAI API

Skicka en begäran till bildgenererings-endpointen med output_format satt till "gif". Två inställningar är specifika för GIF:ar:

Med standarderna får du 9 rutor på 200 ms vardera, alltså en 1,8 sekunders loop.

Jag körde koden nedan i Google Colab med version 3.46 av paketet openai, och den fungerade som skrivet. API:t matchade varje inställning exakt, ända ner till storleken 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)
Drivs av

image-2.6-flare API genererar en orange robot som vinkar i en loop. GIF av författaren.

Jämför den med ChatGPT-roboten. Båda visar en orange robot som vinkar, men den här ser råare ut eftersom koden sätter quality="low" för att spara tid och pengar. Ytan ser repig ut, små delar som antennerna skiftar mellan rutor, och i en ruta blir vinkningen en tumme upp. Låg kvalitet duger för en snabb reaktions-GIF i en chatt. För något med ditt varumärke på, använd "medium" eller "high".

Filen blev 429 kB, nära 500 kB-gränsen som många webbplatser sätter för GIF:ar.

Innan du bygger vidare, känn till två begränsningar:

• Ingen streaming: Partiella bilder och output_compression fungerar inte heller med GIF-utdata.

• En pixelbudget: Antal bildrutor, bildrutestorlek och n måste alla rymmas inom en total. Om en begäran misslyckas, skär ner på en av dem.

Hur får du en mjuk loop?

Be i din prompt om en rörelse som slutar där den började, och säg vad som ska vara stilla. Om sista rutan inte matchar första ser du ett hopp varje gång GIF:en börjar om. Att sakta ner med frame_duration_ms döljer inte det hoppet. Be i stället om att handlingen ska återgå till startposen, som jag gjorde med roboten och fågeln.

I praktiken:

• Välj en liten, reversibel handling, såsom en vinkning eller en blinkning.
• Håll kamera, bakgrund och skala fasta.
• Lämna text utanför bildrutan.
• Titta på flera hela loopar och kontrollera mellanrutor, inte bara första och sista. Det var där min API-robot smög in sin tumme upp.

Kontrollera filstorleken innan du lägger en GIF på en webbplats. Min 512x512, 9-ruters robot landade redan på 429 kB, så 1024x1024 med 16 rutor kommer inte i närheten av en 500 kB-gräns.

Avslutande tankar

Om du gör GIF:ar för sociala inlägg, maskotar eller storyboardar är Images 2.6 en stor förändring, eftersom du inte längre behöver ett separat verktyg för att animera dina bilder.

Men om GIF:ar inte är din grej och du letar efter ett verktyg för stillbilder, jämför vår guide till de bästa gratis AI-bildgeneratorerna några bra alternativ. För att se hur Google hanterar samma redigeringsproblem, läs vår Nano Banana 2-guide.