Guide de démarrage rapide de FLUX API : générez des images avec CometAPI

Ce que vous allez créer

Vous soumettrez une tâche 1280x768 PNG à FLUX.2 Pro, enregistrerez l’id associé à la tâche renvoyée, interrogerez GET /flux/v1/get_result, et téléchargerez result.sample lorsque la tâche passera à l’état Ready. Pour une requête synchrone, envoyez "async": false et lisez result.sample dans la réponse de création. Consultez Générer de manière synchrone pour des exemples complets.

Prérequis

Une clé API CometAPI stockée dans COMETAPI_KEY
curl et jq, Python 3.10+ avec requests, ou Node.js 18+
Accès à flux-2-pro sur votre compte CometAPI

Points de terminaison et authentification

Soumettez la tâche :

POST https://api.cometapi.com/flux/v1/flux-2-pro

Interrogez à l’aide du id de premier niveau renvoyé par la réponse de création :

GET https://api.cometapi.com/flux/v1/get_result?id=<task_id>

Authentifiez les deux requêtes CometAPI avec :

Authorization: Bearer $COMETAPI_KEY

Exemples de code

set -e

CREATE_RESPONSE=$(curl --max-time 60 -fSs https://api.cometapi.com/flux/v1/flux-2-pro \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A clean editorial photograph of a red ceramic teapot on a pale blue table, a small yellow lemon on the right, soft window light, no text.",
    "width": 1280,
    "height": 768,
    "output_format": "png",
    "seed": 424242
  }')

TASK_ID=$(printf "%s" "$CREATE_RESPONSE" | jq -r '.id')

for ATTEMPT in $(seq 1 60); do
  RESULT=$(curl --max-time 30 -fSs "https://api.cometapi.com/flux/v1/get_result?id=$TASK_ID" \
    -H "Authorization: Bearer $COMETAPI_KEY")
  STATUS=$(printf "%s" "$RESULT" | jq -r '.status')
  echo "status: $STATUS"

  case "$STATUS" in
    Ready)
      IMAGE_URL=$(printf "%s" "$RESULT" | jq -r '.result.sample')
      curl --max-time 60 -fL "$IMAGE_URL" -o flux-result.png
      exit 0
      ;;
    Error|Failed|Failure|"Task not found"|"Request Moderated"|"Content Moderated"|failed|failure)
      echo "FLUX task failed: $STATUS" >&2
      exit 1
      ;;
  esac

  sleep 5
done

echo "FLUX task did not finish in time" >&2
exit 1

import os
import time
from pathlib import Path

import requests

headers = {"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]}
payload = {
    "prompt": (
        "A clean editorial photograph of a red ceramic teapot on a pale blue "
        "table, a small yellow lemon on the right, soft window light, no text."
    ),
    "width": 1280,
    "height": 768,
    "output_format": "png",
    "seed": 424242,
}

create_response = requests.post(
    "https://api.cometapi.com/flux/v1/flux-2-pro",
    headers={**headers, "Content-Type": "application/json"},
    json=payload,
    timeout=60,
)
create_response.raise_for_status()
task_id = create_response.json()["id"]

failure_statuses = {
    "Error",
    "Failed",
    "Failure",
    "Task not found",
    "Request Moderated",
    "Content Moderated",
    "failed",
    "failure",
}

for _ in range(60):
    result_response = requests.get(
        "https://api.cometapi.com/flux/v1/get_result",
        headers=headers,
        params={"id": task_id},
        timeout=30,
    )
    result_response.raise_for_status()
    result = result_response.json()
    status = result.get("status")
    print(status)

    if status == "Ready":
        image_response = requests.get(result["result"]["sample"], timeout=60)
        image_response.raise_for_status()
        Path("flux-result.png").write_bytes(image_response.content)
        break
    if status in failure_statuses:
        raise RuntimeError(f"FLUX task failed: {status}")

    time.sleep(5)
else:
    raise TimeoutError("FLUX task did not finish in time")

import fs from "node:fs/promises";

const authHeaders = {
  Authorization: `Bearer ${process.env.COMETAPI_KEY}`,
};

const createResponse = await fetch(
  "https://api.cometapi.com/flux/v1/flux-2-pro",
  {
    method: "POST",
    headers: { ...authHeaders, "Content-Type": "application/json" },
    signal: AbortSignal.timeout(60_000),
    body: JSON.stringify({
      prompt:
        "A clean editorial photograph of a red ceramic teapot on a pale blue table, a small yellow lemon on the right, soft window light, no text.",
      width: 1280,
      height: 768,
      output_format: "png",
      seed: 424242,
    }),
  },
);

if (!createResponse.ok) throw new Error(await createResponse.text());
const { id } = await createResponse.json();

const failureStatuses = new Set([
  "Error",
  "Failed",
  "Failure",
  "Task not found",
  "Request Moderated",
  "Content Moderated",
  "failed",
  "failure",
]);
let completed = false;

for (let attempt = 0; attempt < 60; attempt += 1) {
  const resultResponse = await fetch(
    `https://api.cometapi.com/flux/v1/get_result?id=${encodeURIComponent(id)}`,
    { headers: authHeaders, signal: AbortSignal.timeout(30_000) },
  );
  if (!resultResponse.ok) throw new Error(await resultResponse.text());

  const result = await resultResponse.json();
  console.log(result.status);

  if (result.status === "Ready") {
    const imageResponse = await fetch(result.result.sample, {
      signal: AbortSignal.timeout(60_000),
    });
    if (!imageResponse.ok) throw new Error(await imageResponse.text());
    await fs.writeFile(
      "flux-result.png",
      Buffer.from(await imageResponse.arrayBuffer()),
    );
    completed = true;
    break;
  }
  if (failureStatuses.has(result.status)) {
    throw new Error(`FLUX task failed: ${result.status}`);
  }

  await new Promise((resolve) => setTimeout(resolve, 5000));
}

if (!completed) throw new Error("FLUX task did not finish in time");

Générer de manière synchrone

Pour recevoir l’image terminée dans la réponse de création, envoyez le booléen JSON false dans async. Une réponse réussie contient status: "Ready" et une URL d’image dans result.sample. Utilisez true ou omettez async pour utiliser le flux de travail asynchrone ci-dessus. N’envoyez pas "false" sous forme de chaîne et ne combinez pas async: false avec webhook_url ni webhook_secret. Ces exemples attendent jusqu’à 300 secondes la réponse de création, puis téléchargent l’image. Le délai d’attente est un paramètre client, et non une échéance de fin :

set -e

RESULT=$(curl \
  https://api.cometapi.com/flux/v1/flux-2-pro \
  --max-time 300 \
  --fail-with-body \
  --silent \
  --show-error \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A red ceramic teapot on a pale blue table, soft window light.",
    "width": 1280,
    "height": 768,
    "output_format": "png",
    "seed": 424242,
    "async": false
  }')

if [ "$(printf '%s' "$RESULT" | jq -r '.status')" != "Ready" ]; then
  echo "FLUX generation did not return a Ready result" >&2
  exit 1
fi

IMAGE_URL=$(printf '%s' "$RESULT" | jq -er '.result.sample')
curl \
  "$IMAGE_URL" \
  --max-time 60 \
  --fail \
  --location \
  --output flux-result.png

import os
from pathlib import Path

import requests

response = requests.post(
    "https://api.cometapi.com/flux/v1/flux-2-pro",
    headers={
        "Authorization": "Bearer " + os.environ["COMETAPI_KEY"],
        "Content-Type": "application/json",
    },
    json={
        "prompt": "A red ceramic teapot on a pale blue table, soft window light.",
        "width": 1280,
        "height": 768,
        "output_format": "png",
        "seed": 424242,
        "async": False,
    },
    timeout=300,
)
response.raise_for_status()
task = response.json()
if task.get("status") != "Ready":
    raise RuntimeError("FLUX generation did not return a Ready result")

image_response = requests.get(task["result"]["sample"], timeout=60)
image_response.raise_for_status()
Path("flux-result.png").write_bytes(image_response.content)

import fs from "node:fs/promises";

const response = await fetch(
  "https://api.cometapi.com/flux/v1/flux-2-pro",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.COMETAPI_KEY}`,
      "Content-Type": "application/json",
    },
    signal: AbortSignal.timeout(300_000),
    body: JSON.stringify({
      prompt: "A red ceramic teapot on a pale blue table, soft window light.",
      width: 1280,
      height: 768,
      output_format: "png",
      seed: 424242,
      async: false,
    }),
  },
);

if (!response.ok) throw new Error(await response.text());
const task = await response.json();
if (task.status !== "Ready") {
  throw new Error("FLUX generation did not return a Ready result");
}

const imageResponse = await fetch(task.result.sample, {
  signal: AbortSignal.timeout(60_000),
});
if (!imageResponse.ok) throw new Error(await imageResponse.text());
await fs.writeFile(
  "flux-result.png",
  Buffer.from(await imageResponse.arrayBuffer()),
);

Fonctionnement du flux

Avec async: true ou sans champ async, le point de terminaison de création renvoie un identifiant de tâche de niveau supérieur id tandis que la génération se poursuit. Interrogez le point de terminaison des résultats CometAPI avec cet identifiant id. Ready est l’état terminal indiquant la réussite. Considérez les états d’erreur et de modération connus comme des échecs et continuez d’interroger les autres états uniquement jusqu’à l’expiration du délai d’attente de votre client. Avec async: false, la réponse de création réussie contient status: "Ready" et result.sample. Lisez directement l’URL de l’image sans interrogation. Utilisez result.sample uniquement pour télécharger l’image terminée. Il s’agit d’une URL temporaire qui ne doit pas être utilisée comme stockage durable de l’application.

Paramètres communs

Paramètre	Utilisation
`model` segment de chemin	ID de modèle FLUX.2 dans le chemin de l’URL. Ce guide de démarrage rapide utilise `flux-2-pro` ; consultez Modèles pour connaître la disponibilité selon votre compte.
`prompt`	Description d’image ou instruction de modification requise.
`async`	Booléen JSON facultatif. `false` attend l’image dans la réponse de création ; `true` ou l’omission soumet une tâche asynchrone. Ne combinez pas `false` avec `webhook_url` ni `webhook_secret`.
`width` / `height`	Dimensions de sortie demandées, en pixels.
`output_format`	Format pris en charge par le modèle sélectionné. Ce guide de démarrage rapide utilise `png`.
`seed`	Valeur de seed facultative. Le résultat peut indiquer la seed utilisée ; ce champ seul ne garantit pas une sortie reproductible.
`input_image`	URL HTTPS publique d’image de référence pour la modification.
`input_image_2`	Deuxième URL HTTPS publique d’image de référence pour FLUX.2 Pro ; envoyez également `input_image`.

Résolution des problèmes

La tâche reste à l’état de traitement

Continuez l’interrogation dans une boucle de tentatives limitée. Si le délai d’expiration du client est atteint, conservez l’ID de la tâche pour une inspection ultérieure et signalez la requête comme ayant expiré plutôt que comme réussie.

L’URL de l’image ne fonctionne plus

Téléchargez result.sample rapidement une fois que la tâche est Ready, puis placez l’image dans un stockage contrôlé par votre application.

Un champ de requête n’a aucun effet

Utilisez la Référence de l’API Generate a FLUX image pour choisir les champs de requête pour votre modèle. Vérifiez les noms de champs et les types JSON par rapport à l’exemple de requête.

Étapes suivantes

Lisez la Référence de l’API Generate a FLUX image.
Interrogez les résultats avec Obtenir un résultat d’image FLUX.
Trouvez les modèles FLUX disponibles dans Modèles.

Commencez ici

Démarrages rapides de l’API des modèles

Guides de l’API principale

Bibliothèques

Erreurs

Tarification et facturation

Assistance

Guide de démarrage rapide de FLUX API : générez des images avec CometAPI

Ce que vous allez créer

Prérequis

Points de terminaison et authentification

Exemples de code

Générer de manière synchrone

Fonctionnement du flux

Paramètres communs

Résolution des problèmes

Étapes suivantes

​Ce que vous allez créer

​Prérequis

​Points de terminaison et authentification

​Exemples de code

​Générer de manière synchrone

​Fonctionnement du flux

​Paramètres communs

​Résolution des problèmes

​Étapes suivantes

Ce que vous allez créer

Prérequis

Points de terminaison et authentification

Exemples de code

Générer de manière synchrone

Fonctionnement du flux

Paramètres communs

Résolution des problèmes

Étapes suivantes