GPT Image 2.6 Sunburst GIF-Erstellung: Detaillierte Größenangaben zu 4 Collage-Layouts und Größenlimits für 2–16 Frames

Anmerkung des Autors: Wenn du mit GPT Image 2.6 Sunburst ein GIF erzeugst, bezieht sich size auf die Größe eines einzelnen Frames. Die eigentliche Beschränkung gilt für das Sprite Sheet, das aus allen Frames zusammengesetzt wird. Dieser Artikel schlüsselt diese Regeln Tabellenform Punkt für Punkt auf und nennt die maximal zulässigen Größen für verschiedene Frame-Anzahlen.

Viele Entwickler stoßen beim ersten Einsatz von gpt-image-2.6-sunburst für GIFs auf folgendes Problem: Sie setzen size auf 1024×1024 und nur 2 Frames, doch die API antwortet direkt mit 400. Der Grund: Für GIFs gelten andere Größenregeln als für statische Bilder. Dieser Artikel stellt die dreistufige Umrechnungsmethode „Frame-Größe → Sprite-Sheet-Layout → Sprite-Sheet-Grenzen“ vor. Damit kannst du beurteilen, ob eine beliebige Kombination aus size und frame_count die Validierung besteht.

Das ist keine bloße Übersetzung einer Parameterbeschreibung. Die Grenzwerte in diesem Artikel stammen aus Messungen vom 2026-11-09 auf der offiziellen Weiterleitungsroute; für jede Obergrenze in den Tabellen ist die Herleitung angegeben, sodass du sie selbst nachprüfen kannst.

Der zentrale Nutzen: Nach der Lektüre kannst du anhand der Frame-Anzahl die passende Einzelbildgröße wählen, Fehler wie GIF frames exceed the total request pixel budget vermeiden und weißt, wie du zwischen 512×512, 768×768 und 960×960 abwägst.

GPT Image 2.6 Sunburst: Die wichtigsten Punkte zu GIF-Größen

Die folgende Tabelle gibt einen Überblick über die zentralen Regeln bei der GIF-Erzeugung; anschließend gehen wir sie einzeln durch.

Frame-Sheet-Mechanik bei GPT Image 2.6 GIFs

Die GIF-Erzeugung mit GPT Image 2.6 Sunburst läuft in zwei Schritten: Zuerst werden alle Frames nach einem festen Raster in ein großes Bild gezeichnet, anschließend wird dieses große Bild in einzelne Frames zerlegt und mit frame_duration_ms zur Animation zusammengesetzt. Die Größenbeschränkungen beziehen sich daher nicht auf das einzelne Frame, sondern auf die Kantenlänge des Frame-Sheets, die Gesamtpixelzahl und das Verhältnis von langer zu kurzer Seite.

Das Layout folgt festen Stufen nach der Frame-Anzahl und wird nicht etwa kompakt nach der tatsächlichen Frame-Anzahl gepackt. Wenn frame_count beispielsweise auf 2 gesetzt ist, verwendet das System trotzdem ein 4×2-Layout. Ein Beispiel aus den Referenzunterlagen belegt das: Bei einem einzelnen Frame von 2048×2048 braucht ein Frame-Sheet mit nur 2 Frames bereits 8192×4096. Bei der Schätzung müssen Sie unbedingt die „Anzahl der Rasterzellen des Layouts“ verwenden und nicht die „tatsächliche Frame-Anzahl“.

Grundlegende Parameter von GPT Image 2.6 GIFs

Neben size gibt es beim GIF noch zwei eigene Parameter: frame_count steuert die Anzahl der Frames, frame_duration_ms die Anzeigedauer pro Frame. Die Gesamtdauer ergibt sich aus Frame-Anzahl mal Dauer pro Frame. Beispiel: 2 Frames × 100 ms ergeben eine Schleife von 0,2 Sekunden.

Besondere Aufmerksamkeit verdient das Verhalten von frame_count außerhalb des zulässigen Bereichs. Bei 1 oder 17 gibt die API keinen 400-Fehler zurück, sondern verwirft frame_count und frame_duration_ms und fällt auf die Standardwerte 9 Frames und 1,8 Sekunden zurück. Die Anfrage ist also „erfolgreich“, das Ergebnis entspricht aber nicht dem, was Sie wollten. In solchen Fällen müssen Sie nach der Generierung mit einem Tool die tatsächliche Frame-Anzahl prüfen; wie das geht, steht im Schnellstartabschnitt.

GPT Image 2.6 Sunburst GIF – Größenlimits im Detail

Dieser Abschnitt ist der Kern des Artikels. Kombiniert man die Einschränkungen für das Sprite-Sheet mit den Layout-Regeln, lassen sich daraus die Größenobergrenzen für jede Stufe der Frame-Anzahl ableiten.

Die vier Einschränkungen für das Sprite-Sheet von GPT Image 2.6

Die Obergrenzen sind relativ leicht nachvollziehbar. Die Kantenlänge von 3840 Pixeln und die Gesamtpixelzahl von 8.294.400 sind zwei unabhängige Hürden, die gleichzeitig erfüllt sein müssen. Bei wenigen Frames stößt die Breite des Sprite-Sheets in der Regel zuerst an die Kantenlänge; bei vielen Frames ist meist zuerst das Gesamtpixelbudget erschöpft.

Die Untergrenze wird oft übersehen. Der im Test abgelehnte Wert von 589.824 entspricht genau 768×768 – also einem 3×3-Sprite-Sheet mit 9 Frames von jeweils 256×256. Der akzeptierte Wert von 665.856 ist 816×816 und entspricht 9 Frames mit jeweils 272×272. Daraus lässt sich ableiten, dass auch eine zu kleine Frame-Größe in Kombination mit einem Layout mit wenigen Zellen wegen eines zu kleinen Sprite-Sheets abgelehnt werden kann. Beispielsweise ergibt ein 4×2-Layout mit 256×256 pro Frame ein Sprite-Sheet von nur 1024×512, also insgesamt 524.288 Pixel – unterhalb der Untergrenze. Auch der Ansatz „Größe reduzieren, um Kosten zu sparen“ hat also eine Untergrenze.

Der Einfluss des Seitenverhältnisses zeigt sich bei nicht quadratischen Frames deutlicher. Rechnet man mit einem 4×2-Layout, ergibt sich bei 16:9-Frames ein Breite-zu-Höhe-Verhältnis des Sprite-Sheets von etwa 3,56:1 – mehr als 3:1. Bei einem 3×3- oder 4×4-Layout sinkt das Verhältnis wieder. Diese Werte sind aus den Regeln abgeleitet; vor dem Livegang sollte man sie durch einen Praxistest bestätigen.

GPT Image 2.6: Obergrenze für quadratische Einzelbilder je Frameanzahl

Die folgenden Obergrenzen gelten für „quadratisches Einzelbild + Breite und Höhe als Vielfache von 16“ und lassen sich direkt nachschlagen.

Zwei Details sind erwähnenswert.

• 10–12 Frames werden als 12 Zellen gerechnet: Das Layout ist 4×3. Selbst wenn nur 10 Frames benötigt werden, belegt die Collage Pixel für 12 Zellen. In Tests wurde die Kombination aus 12 Frames und 832² bereits wegen einer Überschreitung um 12.288 Pixel abgelehnt – das Budget wird also strikt eingehalten.
• 2–8 Frames sind durch die Kantenlänge begrenzt: In dieser Stufe sind noch Gesamtpixel übrig, aber die Collagebreite ist das Vierfache der Einzelbildbreite. Daher ist 960 bereits die Obergrenze. Bei 1024 würde die Collagebreite 4096 betragen.

GPT Image 2.6: Wie man die gängigen Größen auswählt

Wenn man die oben genannten Obergrenzen in eine konkrete Auswahl übersetzt, ergeben sich die folgenden Empfehlungen:

1024×1024 ist bei statischen Bildern sehr verbreitet, für GIFs aber völlig unbrauchbar. Bei 2–8 Frames und 10–12 Frames ist das Frame-Raster 4096 breit und überschreitet damit 3840; bei 9 Frames ist es 3072×3072 mit insgesamt 9,437,184 Pixeln und sprengt das Budget; bei 13–16 Frames ist die Rasterbreite ebenfalls 4096. Wenn du also von statischen Bildern auf GIFs umsteigst, ist die erste Maßnahme, die Standardgröße zu verkleinern.

Wenn du ein Querformat brauchst, empfiehlt sich 9 Frames mit 1280×720. Das Frame-Raster ist dann ein 3×3-Layout, genau 3840×2160, mit einem Seitenverhältnis von 16:9 – alle drei Einschränkungen sind erfüllt.

💡 Empfehlung zur Auswahl: Die Größenobergrenzen sind das Ergebnis einer regelbasierten Berechnung; auf der Modellseite kann das Budget angepasst werden. Vor dem Livegang solltest du auf APIYI apiyi.com mit quality: "low" eine Reihe von Grenzwerttests laufen lassen, um mit minimalen Kosten zu bestätigen, dass deine häufig verwendeten Größenkombinationen funktionieren.

GPT Image 2.6 Sunburst GIF – Schnelleinstieg

GPT Image 2.6 GIF – Minimalbeispiel

Hier ist das kostengünstige Beispiel aus der Referenzdokumentation: 2 Frames, je 100 ms pro Frame, Gesamtdauer 0,2 Sekunden. Es entsteht eine Schleifenanimation, bei der ein gelber Kreis nach rechts wandert und wieder an seinen Ausgangspunkt zurückkehrt. Felder wie frame_count sind GIF-spezifisch – deshalb senden wir hier einfach direkt JSON per requests, das ist am anschaulichsten.

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

Beim Schreiben der Eingabeaufforderung solltest du drei Dinge klar beschreiben: Was ist das Motiv, wie bewegt es sich, und wie läuft die Schleife ab. Formulierungen wie „zurück zur Ausgangsposition“ oder „seamless loop“ sorgen dafür, dass Anfangs- und Endframe natürlicher ineinandergreifen.

GPT Image 2.6 GIF-Größenprüfung und vollständige Implementierung

In der Produktionsumgebung empfiehlt es sich, vor der Anfrage eine lokale Vorabprüfung durchzuführen und ungültige Größen frühzeitig abzufangen. Das spart einen 400-Hin-und-Rück-Roundtrip. Der folgende Code überführt die Layout-Tabelle und die Einschränkungen aus diesem Artikel in Funktionen und unterstützt dabei sowohl die Generierungs- als auch die Bearbeitungsschnittstelle.

import base64
import requests
from typing import Optional

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.apiyi.com/v1"  # APIYI – OpenAI-kompatible Schnittstelle

MAX_EDGE = 3840
MAX_PIXELS = 8_294_400   # 3840 x 2160
MIN_PIXELS = 655_360     # nahe der gemessenen Untergrenze, dient nur als Warnung
MAX_RATIO = 3.0


def sheet_layout(frame_count: int) -> tuple[int, int]:
    """Gibt das feste Collage-Layout (Spalten, Zeilen) passend zur Frameanzahl zurück"""
    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]:
    """Gibt eine Liste von Problemen zurück; eine leere Liste bedeutet, dass die Vorprüfung bestanden ist"""
    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:  # Edit-Endpunkt: Das erste Bild dient als Motiv der 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))   # Erwartet: Gesamtpixelzahl überschreitet das Budget
    print(check_gif_size(1280, 720, 9))   # Erwartet: [] – bestanden
    create_gif(
        prompt="让这只猫跳一小段舞，纯色背景，固定镜头，最后一个动作回到起始姿势",
        size="512x512",
        frame_count=16,
        frame_duration_ms=100,
        image_url="https://example.com/cat.png",
        out_path="cat_dance.gif",
    )

Mit ffprobe die tatsächliche Frame-Anzahl von GPT Image 2.6 GIFs überprüfen

Wenn frame_count außerhalb des gültigen Bereichs liegt, fällt es stillschweigend auf 9 Frames zurück. Bei Batch-Aufgaben solltet ihr deshalb am besten einen zusätzlichen Schritt zur Überprüfung der tatsächlichen Frame-Anzahl einbauen:

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

Das Minimalbeispiel sollte 2 ausgeben. Wenn 9 ausgegeben wird, hat der Frame-Parameter keine Wirkung gehabt – dann solltet ihr prüfen, ob der übergebene Wert zwischen 2 und 16 liegt.

Funktionale Einschränkungen von GPT Image 2.6 GIF

Der GIF-Modus unterstützt die folgenden Funktionen nicht. Diese dürfen bei der Anfrage nicht mitgegeben werden:

• stream Streaming-Ausgabe und partial images für die progressive Vorschau
• benutzerdefiniertes output_compression
• prompt_rewriter

Außerdem sind frame_count und frame_duration_ms nur für GIF vorgesehen und dürfen nicht an PNG-, JPEG-, WebP- oder SVG-Anfragen übergeben werden.

🚀 Schnellstart: Empfohlen: Nach der Registrierung bei APIYI apiyi.com das kostenlose Testkontingent für neue Nutzer nutzen. Zuerst mit 512×512, 2 Frames und quality: "low" den gesamten Ablauf durchlaufen und dann schrittweise die Frame-Anzahl und die Größe erhöhen. Die Plattform bietet eine OpenAI-kompatible Schnittstelle – mit einem API-Schlüssel lassen sich GPT Image und andere gängige Modelle aufrufen.

Häufige Fragen (FAQ)

GPT Image 2.6 Sunburst GIF-Größen: Das Wichtigste in Kürze

• size ist die Größe eines Einzelbildes: Die Grenzwerte gelten für das Sprite-Sheet, das sich alle Frames teilen – nicht für das einzelne Frame
• Das Layout ist fest gestaffelt: Vier Layouts – 4×2, 3×3, 4×3 und 4×4 – für 2–8, 9, 10–12 bzw. 13–16 Frames
• Drei harte Limits: Kantenlänge des Sprite-Sheets ≤ 3840, Gesamtpixel ≤ 8.294.400, Verhältnis lange zu kurze Seite ≤ 3:1
• Am robustesten ist 512×512: Damit laufen alle 2–16 Frames; bei 768² sind maximal 12 Frames drin, bei 960² maximal 9
• 1024² ist gar nicht nutzbar: Wer Parameter aus der statischen Bilderzeugung übernimmt, muss die Größe zuerst verkleinern
• Frame-Zahlen außerhalb des Bereichs fallen still zurück: Validiere den Bereich am besten clientseitig und prüfe die Frame-Anzahl nach der Generierung mit ffprobe
• Günstig verifizieren: Bei APIYI apiyi.com mit quality: "low" Grenzwerttests fahren – das kostet am wenigsten

Fazit

Die Größenregeln für GIFs mit GPT Image 2.6 Sunburst laufen im Kern auf drei Rechenschritte hinaus:

1. Erst das Layout festlegen: Anhand von frame_count das passende Layout wählen – 4×2, 3×3, 4×3 oder 4×4
2. Dann das Sprite-Sheet berechnen: Breite und Höhe eines Einzelbildes mit Zeilen und Spalten des Layouts multiplizieren – das ergibt Breite, Höhe und Gesamtpixel des Sprite-Sheets
3. Zum Schluss prüfen: Kantenlängen, Ober- und Untergrenze der Gesamtpixel und das Seitenverhältnis kontrollieren und sicherstellen, dass Breite und Höhe ein Vielfaches von 16 sind

Im Alltag ist 512×512 der Standardwert mit der besten Kompatibilität. Wenn es eine größere Fläche sein soll, holst du mit 9 Frames und 960×960 oder 1280×720 das Maximum aus dem Budget heraus. Baust du die Vorabprüf-Funktion aus diesem Artikel in deinen Produktivcode ein, lassen sich die meisten 400-Fehler schon vorher lokal abfangen.

Am schnellsten prüfst du deine Größekombination über APIYI apiyi.com: Die Plattform bietet kostenloses Testkontingent und eine einheitliche, OpenAI-kompatible Schnittstelle – ideal, um die Grenzwerttests vor der eigentlichen Integration abzuschließen.

📚 Referenzen

1. APIYI Dokumentationszentrum – GPT Image 2.6: Schleifenanimationen als GIF erzeugen: offizielle Parameter und in der Praxis getestete Grenzwerte
2. Link: docs.apiyi.com/api-capabilities/gpt-image-2/gpt-image-2-6

3. Beschreibung: umfasst den Parameterbereich für GIFs, die Einschränkungen beim Zusammenfügen von Bildern, Beispiele für Fehlermeldungen sowie die Verwendung der Bearbeitungsschnittstelle

4. FFmpeg offizielle Dokumentation – ffprobe: Werkzeug zum Auslesen von Audio-, Video- und GIF-Metadaten

5. Link: ffmpeg.org/ffprobe.html
6. Beschreibung: dient zur Überprüfung der tatsächlichen Bildanzahl und der Dauer pro Einzelbild des erzeugten GIFs

Autor: APIYI Technikteam
Technischer Austausch: Wenn Sie bei der Konfiguration der GIF-Abmessungen auf Probleme stoßen, kontaktieren Sie uns gerne über die Startseite der APIYI-Website, um weitere Unterstützung bei der Integration zu erhalten.

Weiterführende Artikel

• Versteckte Einschränkungen der GPT Image 2.6 API erklärt: 5 Arten von Kombinationsgrenzen bei GIF, SVG und lokaler Bearbeitung: Erläutern Sie Endpunktbeschränkungen, Parameterkonflikte und Migrationshinweise für die partielle Bearbeitung von GIF, SVG und Markup in der GPT Image 2.6 API, um den Irrtum zu vermeiden, dass ein Modellnamenwechsel allein für die Integration genügt.
• GPT Image 2.6: Der Parameter „Complexity“ erklärt – wie 3 Stufen der „Denktiefe“ die Bildkomposition bei der Bilderzeugung verändern: Erläuterung des neuen Complexity-Parameters von GPT Image 2.6: Wie die Stufen low, medium und high die Szenenplanung beeinflussen, worin der Unterschied zu Quality besteht und wie man die Stufen über die API fair testet und auswählt.
• ChatGPT Images 2.6 veröffentlicht: GIFs und Referenzbilder verfügbar, Bilderzeugung 50 % schneller – wie nutzt man GPT-Image-2.6 Flare und Sunburst?: ChatGPT Images 2.6 vom 4. November 2026 erklärt: GIFs, wiederverwendbare Referenzbilder, Markup-Bearbeitung, SVG-Export, Auswahlregeln für Flare und Sunburst, Kosten der fünf 1024×1024-Stufen sowie Grenzen offizieller Eigenangaben, unabhängiger Ranglisten und unbekannter Informationen.
• GPT-Image-2.6 vs. Nano Banana 2.1: Unterschiede bei GIF, 4K und Preis – welches Modell wählen?: Vergleich von GPT-Image-2.6 und Nano Banana 2.1 nach Ausgabeformat: Animationen und Vektorgrafiken, 4K und mehrere Referenzbilder, zwei Benchmark-Methoden und zwei Abrechnungsmodelle sowie eine Auswahltabelle für drei Aufgabentypen.
• Was hat Grok Imagine heute eingestellt? Lassen sich alte Modelle noch nutzen? Die 4 wichtigsten Punkte zur Migration auf 2.0 im Überblick: Am 2. November 2026 wird nur die Kennung grok-imagine-image-quality außer Betrieb genommen, nicht Grok Imagine insgesamt; dieser Artikel erläutert die Auswirkungen, Preisänderungen, Qualitätsparameter und die Migration auf 2.0.
• Oh mein Gott! Krea 3, wirst du Nano Banana zerstören?: Dieser Artikel zeigt, wie gut sich Krea 3 für Markenwerbung eignet, und führt in 5 Schritten mit Ad Studio von der Website über das Marken-Kit zu 12 statischen Anzeigen – inklusive offizieller Beispielbilder, Kostentabelle und 7 Fallstricken.