GPT Image 2.6 Flare API: Generierung, Bearbeitung und Preisgestaltung

Wofür Flare konzipiert ist

Flare ist auf schnelle Entwürfe, häufige Vorschauen und interaktive Überarbeitungen ausgelegt. Zu den praktischen Einsatzmöglichkeiten gehören das Erkunden von Hintergründen für Produktfotos, das Testen von Kampagnenkompositionen und das Erstellen mehrerer visueller Richtungen, bevor eine zur Fertigstellung ausgewählt wird. GPT Image 2.6 Sunburst ist die auf Details und Konsistenz ausgerichtete Alternative innerhalb derselben Familie. Es handelt sich nicht einfach um einen „Illustrationsmodus“, und Flare ist nicht auf Fotorealismus beschränkt. Vergleichen Sie beide anhand der Details, die für eine Freigabe entscheidend sind: Wiedergabetreue von Etiketten, Layout, Beibehaltung eines freigegebenen Motivs und die Anzahl der erforderlichen Überarbeitungen. Nutzen Sie den Modellkatalog, um die aktuelle Verfügbarkeit zu prüfen. Ein gemeinsam genutztes Konto bedeutet nicht, dass die Eingaben, Aufgabenpfade oder Ausgabeeinstellungen jedes Modells identisch sind.

Richten Sie Ihren API-Schlüssel ein

Erstellen Sie einen Schlüssel im GPT Proto API Keys Dashboard und stellen Sie ihn dann Ihrer serverseitigen Anwendung zur Verfügung:

export GPTPROTO_API_KEY="your_api_key_here"

Halten Sie den Schlüssel aus dem Browser-Code und der Versionskontrolle fern. Laden Sie ihn aus einer Umgebungsvariablen oder dem Secret-Store Ihrer Bereitstellung. Wenn Sie eine lokale .env-Datei verwenden, schließen Sie diese Datei von Commits aus. Für diesen Leitfaden lautet der API-Ursprung https://gptproto.com. Die unten aufgeführten Generierungs- und Bearbeitungspfade enthalten bereits /api/v3; stellen Sie kein /v1 voran und ersetzen Sie nicht die Basis-URL für Chat-Completions. Eine erfolgreiche Anforderung der Modellliste ist kein Beweis dafür, dass eine Bild-Route einen Auftrag abschließen kann. Überprüfen Sie den vollständigen Senden-und-Ergebnis-Ablauf mit einer kleinen Anfrage, bevor Sie die Stapelverarbeitung hinzufügen.

Ein Bild generieren

Die Flare Text-zu-Bild-Route veröffentlicht diesen Endpunkt:

POST https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image

Beginnen Sie mit einem Bild und expliziten Einstellungen, damit die Anfrage leicht zu überprüfen ist:

curl --request POST \
  "https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image" \
  --header "Authorization: Bearer $GPTPROTO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "prompt": "A square studio product photo of a matte navy insulated bottle on a pale gray plinth. Soft side lighting, warm off-white background, room for copy on the left. No text.",
    "n": 1,
    "quality": "medium",
    "size": "1024x1024",
    "enable_sync_mode": false,
    "response_format": "url"
  }'

Das Modell wird über die URL ausgewählt. Diese veröffentlichte Route erfordert kein separates model-Feld, und size ist optional und kein zwingendes drittes Feld.

Anfragefelder

Ergebnis abrufen

Die Übermittlung und der Abruf von Ergebnissen verwenden einen Umschlag, der code, message und data enthält. Ein HTTP-Erfolg allein bedeutet nicht, dass die Generierung abgeschlossen ist. Überprüfen Sie den geschäftsspezifischen code sowie den Vorhersagestatus.

GET https://gptproto.com/api/v3/predictions/{result_id}/result

Verwenden Sie beim Abfragen dieselbe Bearer-Authentifizierung. Für response_format: "url" sind die abgeschlossenen Ausgaben Datei-URLs. Für b64_json kann das dokumentierte Ausgabe-Array Base64-Strings enthalten. In keinem Fall wird für diese GPT Proto-Route die native OpenAI-Annahme data[0].b64_json verwendet. Speichern Sie Assets, die Sie behalten müssen, bewahren Sie deren tatsächlichen Medientyp auf und verlassen Sie sich nicht auf eine nicht dokumentierte Lebensdauer der gehosteten URL.

Python: Übermitteln und Abrufen

Installieren Sie requests in Ihrer Anwendungsumgebung. Das folgende Beispiel übermittelt eine Anfrage, ruft die zurückgegebene Ergebnis-URL ab und gibt die URLs der fertigen Ausgaben aus. Die Fünf-Minuten-Frist ist ein in diesem Beispiel verwendetes Anwendungs-Timeout und keine Servicegarantie.

import os
import time
from urllib.parse import urlparse
import requests
ORIGIN = "https://gptproto.com"
API_KEY = os.environ["GPTPROTO_API_KEY"]
HEADERS = {"Authorization": f"Bearer {API_KEY}"}
def read_envelope(response):
    response.raise_for_status()
    body = response.json()
    if body.get("code") != 200:
        raise RuntimeError(f"GPT Proto request failed: {body.get('message')}")
    data = body.get("data")
    if not isinstance(data, dict):
        raise RuntimeError("Missing prediction data")
    return data
def submit_and_poll(scene, payload, timeout_seconds=300):
    if scene not in {"text-to-image", "image-edit"}:
        raise ValueError("Unsupported scene")
    endpoint = f"{ORIGIN}/api/v3/openai/gpt-image-2.6-flare/{scene}"
    response = requests.post(
        endpoint,
        headers={**HEADERS, "Content-Type": "application/json"},
        json=payload,
        timeout=(10, 120),
    )
    prediction = read_envelope(response)
    prediction_id = prediction.get("id")
    deadline = time.monotonic() + timeout_seconds
    while True:
        status = prediction.get("status")
        if status == "completed":
            outputs = prediction.get("outputs")
            if not isinstance(outputs, list) or not outputs:
                raise RuntimeError("Completed prediction has no outputs")
            return outputs
        if status == "failed":
            raise RuntimeError(
                f"Prediction {prediction_id} failed: {prediction.get('error')}"
            )
        if status not in {"created", "running"}:
            raise RuntimeError(f"Unexpected prediction status: {status}")
        if time.monotonic() >= deadline:
            raise TimeoutError(f"Check prediction {prediction_id} before resubmitting")
        result_url = prediction.get("urls", {}).get("get")
        parsed = urlparse(result_url or "")
        if (
            parsed.scheme != "https"
            or parsed.netloc != "gptproto.com"
            or not parsed.path.startswith("/api/v3/predictions/")
        ):
            raise RuntimeError("Unexpected result URL; check the route documentation")
        time.sleep(2)
        prediction = read_envelope(
            requests.get(result_url, headers=HEADERS, timeout=(10, 60))
        )
if __name__ == "__main__":
    outputs = submit_and_poll(
        "text-to-image",
        {
            "prompt": "A square product photo of a navy bottle on a pale plinth, soft side lighting, no text",
            "n": 1,
            "quality": "medium",
            "size": "1024x1024",
            "enable_sync_mode": False,
            "response_format": "url",
        },
    )
    for output_url in outputs:
        print(output_url)

Speichern Sie das Skript als flare_example.py, wenn Sie dessen Hilfsfunktion im Bearbeitungsbeispiel unten wiederverwenden möchten. Es stoppt absichtlich bei Anforderungsfehlern, anstatt eine potenziell kostenpflichtige Generierung automatisch erneut zu übermitteln. Fügen Sie eine produktionsreife Wiederholungslogik um den entsprechenden Vorgang herum hinzu, nachdem Sie geprüft haben, ob die ursprüngliche Vorhersage existiert.

Node.js: Eine Generierung übermitteln

Mit einer aktuellen Node.js-Laufzeitumgebung, die fetch und AbortSignal.timeout unterstützt, können Sie dasselbe JSON ohne einen SDK-spezifischen Image-Wrapper übermitteln. Speichern Sie dieses Beispiel als .mjs-Datei:

const apiKey = process.env.GPTPROTO_API_KEY;
if (!apiKey) throw new Error("Set GPTPROTO_API_KEY first");
const response = await fetch(
  "https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      prompt: "A square product photo of a navy bottle, soft side lighting, no text",
      n: 1,
      quality: "medium",
      size: "1024x1024",
      enable_sync_mode: false,
      response_format: "url",
    }),
    signal: AbortSignal.timeout(120000),
  },
);
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const body = await response.json();
if (body.code !== 200 || !body.data) {
  throw new Error(body.message || "Prediction submission failed");
}
console.log(JSON.stringify(body.data, null, 2));

Dies gibt die Vorhersage aus, nicht eine fertige Bilddatei. Verwenden Sie den Wert urls.get für authentifiziertes Polling und lesen Sie outputs erst, nachdem der Status completed erreicht hat, gemäß dem oben beschriebenen Workflow.

Referenzbilder bearbeiten

Die Flare image-edit-Route ist von der Generierung getrennt:

POST https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/image-edit

Sie akzeptiert JSON mit den erforderlichen Feldern images und prompt. GPT Proto beschreibt images als ein Array von Strings und erlaubt bis zu 16 Referenzbilder. Sie listet dieselben Einstellungen für Qualität, Größe, Synchronisierung und Bereitstellung auf wie die Generierungs-Route. Bereiten Sie Referenzbilder über den unterstützten Upload-Flow vor und überprüfen Sie die generierte Anfrage. Verwenden Sie diese Referenz-Strings in images; ersetzen Sie diese nicht durch einen lokalen Dateipfad, eine beliebige Base64-Kodierung oder ein Multipart-Feld namens image, ohne die erwartete Eingaberepräsentation zu prüfen. Speichern Sie beispielsweise die Referenz-Strings aus diesem Flow als JSON-Array in GPTPROTO_REFERENCE_IMAGES und verwenden Sie dann den Python-Helfer erneut:

import json
import os
from flare_example import submit_and_poll
references = json.loads(os.environ["GPTPROTO_REFERENCE_IMAGES"])
if (
    not isinstance(references, list)
    or not 1 <= len(references) <= 16
    or not all(isinstance(item, str) and item for item in references)
):
    raise ValueError("Provide 1–16 valid reference strings from the upload flow")
outputs = submit_and_poll(
    "image-edit",
    {
        "images": references,
        "prompt": "Replace only the tabletop with light oak. Preserve the bottle shape, printed label, camera angle, reflections, and shadow direction.",
        "n": 1,
        "quality": "medium",
        "size": "1024x1024",
        "enable_sync_mode": False,
        "response_format": "url",
    },
)
print(outputs)

Masken und Markups sind nicht austauschbar

Das aktuelle GPT Proto-Bearbeitungsschema listet keine mask- oder markup-Felder auf. Senden Sie keine schwarz-weiße Maske oder eine transparente Anmerkungsebene in der Annahme, dass diese als Bearbeitungsgrenze interpretiert wird. OpenAI dokumentiert markup-gesteuerte Bearbeitung in seinem Leitfaden zur Bildgenerierung, aber die Unterstützung durch den Upstream-Anbieter ist kein Beweis dafür, dass die JSON-Route von GPT Proto dieselben Steuerelemente bereitstellt. Beginnen Sie für diese Route mit unterstützten Referenzeingaben und einer präzisen Bearbeitungsanweisung. Vergleichen Sie das Ergebnis mit dem Original, einschließlich der Bereiche, die unverändert bleiben sollten.

Wählen Sie Qualität, Größe und Bereitstellung separat

Verwenden Sie low für kostengünstige Entwürfe, sofern diese den Anforderungen entsprechen, und vergleichen Sie dann medium und höhere Einstellungen für die finalen Assets. Dies ist eine Workflow-Empfehlung, keine garantierte Zusage, dass eine höhere Einstellung immer das beste Bild oder eine bestimmte Latenz liefert.

Die veröffentlichte Größenauswahl umfasst quadratische, Querformat- und Hochformat-Optionen. Die Richtlinien für die Abmessungen erfordern Kanten, die durch 16 teilbar sind, eine maximale Kante von 3.840 Pixeln, ein Seitenverhältnis von nicht mehr als 3:1 und eine Gesamtpixelanzahl zwischen 655.360 und 8.294.400. Beginnen Sie mit den aufgeführten Voreinstellungen, anstatt davon auszugehen, dass jede benutzerdefinierte Breite und Höhe akzeptiert wird.

response_format steuert die Bereitstellung: url oder b64_json. Es wählt nicht PNG, JPEG, WebP, GIF oder SVG aus. Das aktuelle GPT Proto-Anforderungsschema listet weder output_format, frame_count, frame_duration_ms, complexity noch negative_prompt auf.

OpenAI dokumentiert zusätzliche Funktionen, einschließlich SVG- und animierter GIF-Ausgabe. Betrachten Sie diese als Upstream-Funktionen, bis die von Ihnen verwendete GPT Proto-Route diese explizit bereitstellt. Fügen Sie der Anfrage keine undokumentierten Felder hinzu und beschreiben Sie diese Formate nicht als bestätigte Ausgaben dieser Route.

Preise und Kosten pro genehmigtem Bild

Tarife geprüft am 8. November 2026, pazifische Zeit. Die aktuelle Modellreferenz von GPT Proto listet diese Bild-Token-Tarife auf; Preise können sich ändern.

Texteingaben werden separat abgerechnet. Überprüfen Sie den aktuellen Tarif und die angezeigte Genauigkeit, bevor Sie einen vollständigen Auftrag kalkulieren. Die Modellseite bewirbt derzeit Tarife, die 5 % unter dem Listenpreis liegen; dies ist eine modellspezifische Preisangabe, kein garantierter Rabatt über alle Modelle hinweg oder eine feste Ersparnis bei jedem generierten Bild. Zur Veranschaulichung: 1.000 abrechenbare Bildausgabe-Token kosten bei $28,50 pro Million $0,0285. Dies ist ein arithmetisches Beispiel, das nur die Ausgabe abdeckt – keine Prognose darüber, wie viele Token ein bestimmtes Bild verbrauchen wird. Texteingaben, die Verarbeitung von Referenzbildern und wiederholte Generierungen erhöhen die Gesamtsumme.

Die aktuelle Routenreferenz dokumentiert kein usage-Feld in ihrem Vorhersage-Envelope. Verwenden Sie die für Ihr Konto verfügbaren Abrechnungsinformationen; erstellen Sie keine Kostenberichte auf Basis eines unbestätigten Antwortfeldes. Höhere Qualität, größere Ausgaben und zusätzliche Referenzen können den Verbrauch verändern, aber es wurde hier kein fester Multiplikator oder ein gestaffelter Bildpreis festgelegt.

Verfolgen Sie die Gesamtausgaben geteilt durch die genehmigten Assets, um Workflows zu vergleichen. Ein günstigerer Entwurf, der mehrere Überarbeitungen erfordert, kann mehr kosten als ein qualitativ hochwertigeres erstes Ergebnis. Beginnen Sie mit n: 1, verwenden Sie die für die Platzierung erforderlichen Abmessungen und erhöhen Sie das Volumen erst, nachdem Sie sowohl die Ausgabequalität als auch die Abrechnung überprüft haben. Siehe GPT Proto-Preise für die aktuellen Zahlungsbedingungen auf Kontoebene.

Schreiben Sie Prompts, die Sie bewerten können

Beschreiben Sie das Asset, das Motiv, die Komposition, die Beleuchtung, den Stil und die Einschränkungen in einfacher Sprache. Trennen Sie bei einer Bearbeitung die angeforderte Änderung von den Details, die unverändert bleiben müssen. Gehen Sie nicht davon aus, dass eine feste Wortreihenfolge einen dokumentierten Vorteil bei der Token-Gewichtung hat.

Produktkampagne: „Erstelle eine quadratische Studio-Anzeige für eine matte, marineblaue Isolierflasche. Platziere sie auf dem rechten Drittel auf einem blassgrauen Sockel. Halte die linke Hälfte frei für Text. Verwende weiches Seitenlicht und einen warmen, cremeweißen Hintergrund. Das Bild soll frei von Text sein.“

Gezielte Überarbeitung: „Ändere nur die Tischplatte zu heller Eiche. Behalte den Kamerawinkel, die Flaschenform, das gedruckte Etikett, die Reflexionen und die Schattenrichtung bei. Passe die Beleuchtung an die bestehende an.“

Exakter Text: „Erstelle ein Event-Plakat im Hochformat mit der Überschrift ‚NIGHT MARKET‘, exakt wie geschrieben. Verwende eine große Überschrift oben, ein Produktfoto in der Mitte und freien Platz unten für ein Datum, das später hinzugefügt wird.“

Überprüfen Sie die Beschriftung in voller Größe und kontrollieren Sie den endgültigen Zuschnitt. Ein visuell überzeugendes Ergebnis kann dennoch ein falsches Etikett oder einen unbrauchbaren Textbereich enthalten. Der GPT Image 2.5 Prompt-Leitfaden bietet entsprechende Prompting-Übungen; dessen Beispiele sind kein Maßstab für Flare 2.6.

Fehler behandeln, ohne doppelte Jobs zu erstellen

Überprüfen Sie sowohl die HTTP-Antwort als auch den Prediction-Envelope. Die Annahme der Anfrage, der Abschluss der Generierung und der Abruf der Assets sind separate Schritte.

Verwenden Sie für wiederholbare Vorgänge eine begrenzte Wiederholungsrichtlinie mit Jitter. Die Verzögerung, die Anzahl der Versuche und die Anwendungsfrist sind Ihre Konfigurationsentscheidungen – keine garantierten GPT Proto-Standards. Gehen Sie nicht davon aus, dass jede Antwort einen bestimmten Satz von Rate-Limit-Headern enthält.

Protokollieren Sie Prediction-IDs, Antwortstatus, Timing und bereinigte Fehlerdetails. Protokollieren Sie nicht den API-Key, vollständige Referenzbilder oder jeden vollständigen Request-Payload. Stellen Sie nach einem Netzwerk-Timeout nach Möglichkeit die bekannte Prediction wieder her, bevor Sie sie erneut übermitteln; doppelte Generierungen können zusätzliche Kosten verursachen.

Verschieben eines bestehenden Workflows auf Flare 2.6

Ein Upgrade ist mehr als nur das Ersetzen eines Modell-Strings. GPT Proto wählt dieses Modell und diese Aufgabe über den Routenpfad aus. Halten Sie eine bestehende Integration verfügbar, während Sie die neue Generierung oder Edit-Route mit repräsentativen Prompts und Referenzen testen.

Verwenden Sie explizite Einstellungen für Größe, Qualität, Bildanzahl und Bereitstellung. Vergleichen Sie die Textgenauigkeit, die Wahrung von Produktdetails, die Zeit bis zu einem genehmigten Ergebnis und die Gesamtkosten über verschiedene Revisionen hinweg. Überprüfen Sie das Antwort-Parsing und das Polling-Verhalten erneut, bevor Sie wiederkehrenden Produktionstraffic migrieren.

Wenn Sie von einem nativen OpenAI-Image-Client migrieren, passen Sie den Payload und die Ergebnishandhabung an den data.status- und data.outputs-Envelope von GPT Proto an. Gehen Sie nicht davon aus, dass client.images.generate() oder client.images.edit() diese nativen GPT Proto-Routen unverändert aufrufen können.