FLUX API quickstart: Generate images with CometAPI

What you will build

You will submit a 1280x768 PNG task to FLUX.2 Pro, store the returned task id, poll GET /flux/v1/get_result, and download result.sample when the task becomes Ready. For a synchronous request, send "async": false and read result.sample from the create response. See Generate synchronously for complete examples.

Prerequisites

A CometAPI API key stored in COMETAPI_KEY
curl and jq, Python 3.10+ with requests, or Node.js 18+
Access to flux-2-pro on your CometAPI account

Endpoints and authentication

Submit the task:

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

Poll with the top-level id returned by the create response:

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

Authenticate both CometAPI requests with:

Authorization: Bearer $COMETAPI_KEY

Code examples

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

Generate synchronously

To receive the finished image in the create response, send the JSON boolean false in async. A successful response has status: "Ready" and an image URL in result.sample. Use true or omit async to use the asynchronous workflow above. Do not send "false" as a string, or combine async: false with webhook_url or webhook_secret. These examples wait up to 300 seconds for the create response, then download the image. The timeout is a client setting, not a completion deadline:

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()),
);

How the flow works

With async: true or no async field, the create endpoint returns a top-level task id while generation continues. Poll the CometAPI result endpoint with that id. Ready is the successful terminal state. Treat known error and moderation states as failures, and keep polling other states only until your client timeout. With async: false, the successful create response contains status: "Ready" and result.sample. Read the image URL directly without polling. Use result.sample only to download the finished image. It is a temporary URL and should not be used as durable application storage.

Common parameters

Parameter	Use
`model` path segment	FLUX.2 model ID in the URL path. This quickstart uses `flux-2-pro`; check Models for account availability.
`prompt`	Required image description or edit instruction.
`async`	Optional JSON boolean. `false` waits for the image in the create response; `true` or omission submits an asynchronous task. Do not combine `false` with `webhook_url` or `webhook_secret`.
`width` / `height`	Requested output dimensions in pixels.
`output_format`	Format supported by the selected model. This quickstart uses `png`.
`seed`	Optional seed value. The result can report the used seed; that field alone does not establish repeatable output.
`input_image`	Public HTTPS reference-image URL for editing.
`input_image_2`	Second public HTTPS reference-image URL for FLUX.2 Pro; also send `input_image`.

Troubleshooting

The task stays in a processing state

Continue polling within a bounded retry loop. If the client timeout is reached, keep the task ID for later inspection and report the request as timed out rather than successful.

The image URL no longer works

Download result.sample promptly after the task becomes Ready, then place the image in storage that your application controls.

A request field has no effect

Use the Generate a FLUX image API reference to choose the request fields for your model. Check field names and JSON types against the request example.

Next steps

Read the Generate a FLUX image API reference.
Poll results with Get a FLUX image result.
Find available FLUX models in Models.

Start here

Model API quickstarts

Core API guides

Libraries

Errors

Pricing and billing

Support

FLUX API quickstart: Generate images with CometAPI

What you will build

Prerequisites

Endpoints and authentication

Code examples

Generate synchronously

How the flow works

Common parameters

Troubleshooting

Next steps

​What you will build

​Prerequisites

​Endpoints and authentication

​Code examples

​Generate synchronously

​How the flow works

​Common parameters

​Troubleshooting

​Next steps

What you will build

Prerequisites

Endpoints and authentication

Code examples

Generate synchronously

How the flow works

Common parameters

Troubleshooting

Next steps