> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# FLUX API-hurtigstart: Generer bilder med CometAPI

> Opprett en FLUX.2 Pro-bildeoppgave via CometAPI, spør regelmessig til den er Ready, og last ned den resulterende PNG-filen.

## Dette skal du bygge

Du sender inn en `1280x768` PNG-oppgave til FLUX.2 Pro, lagrer den returnerte oppgave-`id`, spør `GET /flux/v1/get_result` regelmessig og laster ned `result.sample` når oppgaven blir `Ready`.

For en synkron forespørsel sender du `"async": false` og leser `result.sample` fra opprettelsessvaret. Se [Generer synkront](#generate-synchronously) for fullstendige eksempler.

## Forutsetninger

* En CometAPI API-nøkkel lagret i `COMETAPI_KEY`
* `curl` og `jq`, Python 3.10+ med `requests`, eller Node.js 18+
* Tilgang til `flux-2-pro` på CometAPI-kontoen din

## Endepunkter og autentisering

Send inn oppgaven:

```text theme={null}
POST https://api.cometapi.com/flux/v1/flux-2-pro
```

Spørr med `id` på øverste nivå som returneres av opprettelsessvaret:

```text theme={null}
GET https://api.cometapi.com/flux/v1/get_result?id=<task_id>
```

Autentiser begge CometAPI-forespørslene med:

```text theme={null}
Authorization: Bearer $COMETAPI_KEY
```

## Kodeeksempler

<CodeGroup>
  ```bash cURL theme={null}
  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
  ```

  ```python Python theme={null}
  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")
  ```

  ```javascript Node.js theme={null}
  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");
  ```
</CodeGroup>

## Generer synkront

For å motta det ferdige bildet i create-svaret, send den boolske JSON-verdien
`false` i `async`. Et vellykket svar har `status: "Ready"` og en bilde-URL
i `result.sample`. Bruk `true` eller utelat `async` for å bruke den asynkrone arbeidsflyten
ovenfor. Ikke send `"false"` som en streng, og ikke kombiner `async: false` med
`webhook_url` eller `webhook_secret`.

Disse eksemplene venter opptil 300 sekunder på create-svaret og laster deretter ned
bildet. Tidsavbruddet er en klientinnstilling, ikke en frist for fullføring:

<CodeGroup>
  ```bash cURL theme={null}
  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
  ```

  ```python Python theme={null}
  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)
  ```

  ```javascript Node.js theme={null}
  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()),
  );
  ```
</CodeGroup>

## Slik fungerer flyten

Med `async: true` eller uten feltet `async` returnerer create-endepunktet en oppgave på toppnivå, `id`, mens genereringen fortsetter. Spør CometAPI-resultatendepunktet gjentatte ganger med denne `id`. `Ready` er den vellykkede endelige tilstanden. Behandle kjente feil- og modereringstilstander som feil, og fortsett å spørre andre tilstander bare til klientens tidsavbrudd.

Med `async: false` inneholder det vellykkede create-svaret `status: "Ready"` og `result.sample`. Les bilde-URL-en direkte uten gjentatte forespørsler.

Bruk `result.sample` kun til å laste ned det ferdige bildet. Det er en midlertidig URL og bør ikke brukes som varig programlagring.

## Vanlige parametere

| Parameter           | Bruk                                                                                                                                                                                              |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `model` banesegment | FLUX.2-modell-ID i URL-banen. Denne hurtigstarten bruker `flux-2-pro`; se [Modeller](/no/overview/models) for tilgjengelighet for kontoen.                                                        |
| `prompt`            | Påkrevd bildebeskrivelse eller redigeringsinstruksjon.                                                                                                                                            |
| `async`             | Valgfri JSON-boolsk verdi. `false` venter på bildet i opprettelsessvaret; `true` eller utelatelse sender inn en asynkron oppgave. Ikke kombiner `false` med `webhook_url` eller `webhook_secret`. |
| `width` / `height`  | Ønskede utdata-dimensjoner i piksler.                                                                                                                                                             |
| `output_format`     | Format som støttes av den valgte modellen. Denne hurtigstarten bruker `png`.                                                                                                                      |
| `seed`              | Valgfri seed-verdi. Resultatet kan oppgi seed-verdien som ble brukt; dette feltet alene sikrer ikke repeterbart utdata.                                                                           |
| `input_image`       | Offentlig HTTPS-URL til referansebilde for redigering.                                                                                                                                            |
| `input_image_2`     | Andre offentlige HTTPS-URL til referansebilde for FLUX.2 Pro; send også `input_image`.                                                                                                            |

## Feilsøking

<AccordionGroup>
  <Accordion title="Oppgaven forblir i en behandlingstilstand">
    Fortsett å polle innenfor en avgrenset løkke for nye forsøk. Hvis klienttidsavbruddet nås, behold oppgave-ID-en for senere inspeksjon, og rapporter forespørselen som tidsavbrutt i stedet for vellykket.
  </Accordion>

  <Accordion title="Bilde-URL-en fungerer ikke lenger">
    Last ned `result.sample` umiddelbart etter at oppgaven blir `Ready`, og plasser deretter bildet i lagring som applikasjonen din kontrollerer.
  </Accordion>

  <Accordion title="Et forespørselsfelt har ingen effekt">
    Bruk [API-referanse for generering av FLUX-bilder](/no/api/image/flux/flux-generate-image) for å velge forespørselsfeltene for modellen din. Kontroller feltnavn og JSON-typer mot forespørselseksemplet.
  </Accordion>
</AccordionGroup>

## Neste trinn

* Les [API-referanse for generering av FLUX-bilder](/no/api/image/flux/flux-generate-image).
* Hent resultater med [Hent et FLUX-bilderesultat](/no/api/image/flux/flux-query).
* Finn tilgjengelige FLUX-modeller i [Modeller](/no/overview/models).