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

# Use Krea 3 with Comfy Router

> Call krea/krea-3 through Comfy Router: endpoint, request shape and the response Router returns.

API Reference for `krea/krea-3`, served by Comfy Router from Krea.

**Input:** Text, Image · **Output:** Image

## Quick start

Create a key in [your Comfy workspace](https://platform.comfy.org/profile/api-keys?onboarding=router) and export it as `COMFY_API_KEY`. The Python and TypeScript snippets use the Comfy SDKs (`pip install comfy-sdk` and `npm install @comfyorg/sdk`); the cURL snippet is the same call over raw HTTP.

**Model ID:** `krea/krea-3`

**Endpoint:** `POST https://api.comfy.org/v2/models/krea/krea-3`

> [tab] Wait for the result
>
> ```python Python theme={null}
> from comfy_sdk import Comfy
>
> # Reads COMFY_API_KEY from the environment.
> # The SDK automatically creates an idempotency key and reuses it for automatic retries.
> with Comfy() as client:
>     result = client.models.run(
>         "krea/krea-3",
>         {
>             "prompt": "A ceramic coffee mug on a clean studio background",
>             "resolution": "1k",
>         },
>     )
>
> print(result)
> ```
>
> ```typescript TypeScript theme={null}
> import { comfy } from "@comfyorg/sdk";
>
> // Reads COMFY_API_KEY from the environment.
> // The SDK automatically creates an idempotency key and reuses it for automatic retries.
> const { data } = await comfy.models.run("krea/krea-3", {
>   prompt: "A ceramic coffee mug on a clean studio background",
>   resolution: "1k",
> });
>
> console.log(data);
> ```
>
> ```bash cURL theme={null}
> curl https://api.comfy.org/v2/models/krea/krea-3 \
>   -H "X-API-Key: $COMFY_API_KEY" \
>   -H "Idempotency-Key: $(uuidgen)" \
>   -H "Content-Type: application/json" \
>   -d "{\"prompt\": \"A ceramic coffee mug on a clean studio background\", \"resolution\": \"1k\"}"
> ```

> [tab] Queue and collect later
>
> The same body, sent to `POST https://api.comfy.org/v2/models/krea/krea-3/requests`. Router answers `201` with a `request_id` as soon as the run is admitted, and the result is collected once it is ready, from this process or another one. [Queued delivery](https://docs.comfy.org/development/comfy-router/queue.md) walks through status, cancellation and collection.
>
> ```python Python theme={null}
> import asyncio
> from comfy_sdk import AsyncComfy
>
> # Reads COMFY_API_KEY from the environment.
> # Each submit() call mints its own Idempotency-Key and reuses it for automatic retries.
> async def main():
>     async with AsyncComfy() as client:
>         handle = await client.models.submit(
>             "krea/krea-3",
>             {
>                 "prompt": "A ceramic coffee mug on a clean studio background",
>                 "resolution": "1k",
>             },
>         )
>         print("request_id:", handle.request_id)  # with the model ID, all another process needs
>
>         # Poll until the request completes, waiting the Retry-After the server names.
>         async for update in handle.iter_events():
>             print(update.status, update.queue_position)
>
>         # The provider's own payload, the same value models.run() returns.
>         # A request that failed or was cancelled raises the typed Router error here.
>         result = await handle.get()
>
>     print(result)
>
> asyncio.run(main())
> ```
>
> ```typescript TypeScript theme={null}
> import { comfy } from "@comfyorg/sdk";
>
> // Reads COMFY_API_KEY from the environment.
> // Each submit() call mints its own Idempotency-Key and reuses it for automatic retries.
> const handle = await comfy.models.submit("krea/krea-3", {
>   prompt: "A ceramic coffee mug on a clean studio background",
>   resolution: "1k",
> });
> console.log("requestId:", handle.requestId); // with the model ID, all another process needs
>
> // Poll until the request completes, waiting the Retry-After the server names.
> for await (const update of handle.events()) {
>   console.log(update.status, update.queuePosition);
> }
>
> // The same result models.run() returns. A request that failed or was cancelled rejects here.
> const result = await handle.get();
>
> console.log(result.data);
> ```
>
> ```bash cURL theme={null}
> # 1. Submit. Router answers 201 with request_id, status_url, response_url and cancel_url.
> curl https://api.comfy.org/v2/models/krea/krea-3/requests \
>   -H "X-API-Key: $COMFY_API_KEY" \
>   -H "Idempotency-Key: $(uuidgen)" \
>   -H "Content-Type: application/json" \
>   -d "{\"prompt\": \"A ceramic coffee mug on a clean studio background\", \"resolution\": \"1k\"}"
>
> # 2. Poll until status is COMPLETED, waiting the Retry-After seconds each response names.
> REQUEST_ID="<request_id from the 201 body>"
> curl -i https://api.comfy.org/v2/models/krea/krea-3/requests/$REQUEST_ID/status \
>   -H "X-API-Key: $COMFY_API_KEY"
>
> # 3. Collect. 200 with the model's native output, 202 with the status body while it is still running.
> curl https://api.comfy.org/v2/models/krea/krea-3/requests/$REQUEST_ID \
>   -H "X-API-Key: $COMFY_API_KEY"
> ```

## Schema

### Input

**aspect\_ratio** `string`

1:1, 4:5, 3:4, 2:3, 9:16, 5:4, 4:3, 3:2, 16:9 or 21:9. Use with resolution; omit for automatic framing.

**image\_urls** `string[]`

Input image URLs, up to 8. More than 8 entries is rejected before any fetch (400 on /proxy/krea; Comfy Router's schema check answers 422 first). The image\_url returned by uploading the image to POST /proxy/krea/assets (multipart form field `file`) is always accepted. Whether other public https URLs are accepted depends on the environment: where they are not, any link that is not an https URL on the host app-uploads.krea.ai is rejected with 400 saying 'image\_urls must be image\_url values returned by POST /proxy/krea/assets', so upload the image instead; where they are, any public https image URL is accepted, and a URL that is malformed or not https is rejected with 400 (a URL whose port is numeric but out of range is not caught by this check and can fail with a 502 instead). In that case a request with any image\_urls entry that is not an app-uploads.krea.ai link (a public https URL, or a base64 data: URI where those are accepted) is also rejected with 400 before any fetch unless the whole request body is sent as application/json rather than multipart, is valid UTF-8, is at most 25100288 bytes, and carries only the fields this schema declares. For a well-formed https URL in that case, a reference the caller can fix is rejected with 400 naming its host: its host does not resolve or is not publicly reachable when checked before the fetch, it redirects more than the allowed number of times, to a URL that is not https, or to a host that is not publicly reachable, it returns a 4xx other than 408 or 429, it is not an image, it is an image in a format that cannot be read, its image size header is not within the first 2 MiB, or a response with no declared length or chunked encoding ends before its image size header. Any other failure fetching it fails with a 502 error on POST /proxy/krea (Comfy Router answers it with 500 internal\_error): a transient DNS, TLS or connection failure, a timeout, an origin 408, 429, 5xx or other non-200 status, or a host that passed that check but does not resolve or is not publicly reachable when the fetch connects. Some of these clear on retry (a resolver error, timeout, dropped connection, an origin answering 5xx, 408 or 429, or a host whose DNS answer switches to a non-public address between the host check and the connection, which on retry can succeed or get the 400 for a non-public host); others fail the same way every time, for example a TLS certificate the fetch does not trust (self-signed, expired or for the wrong host name), or an origin answering a 2xx other than 200 or a 3xx the fetch does not follow (such as 204, 206, 300, 304 or 305, or a 301, 302, 303, 307 or 308 with no Location), so if a retry fails the same way, upload the image instead. A request queued through Comfy Router does not retry such a failure when any of its image\_urls is not an app-uploads.krea.ai link, so resubmit it yourself if the cause can clear. Where other URLs are not accepted, an app-uploads.krea.ai link that is not a live upload fails with a 5xx error; where they are, it is rejected with 400 like any other unreachable reference. While a server has not yet learned which applies, any https URL with a host that is not an app-uploads.krea.ai link, public or not, fails with a 503 error that is safe to retry (a queued request is retried on it automatically). A queued request's 400 carries only the generic invalid\_input detail, so it shows neither the host nor the wording above, and the queue does not retry it. A queued 400 can come from any field, not only image\_urls (for example an unsupported resolution or thinking\_mode), so check the other fields first. If they are valid, upload each image to POST /proxy/krea/assets and resubmit with those image\_url values and a new Idempotency-Key (or none): reusing the key with a changed body is refused with 409 invalid\_input, which says nothing about the images, and reusing it with the same body is answered 201 with the original request\_id and Idempotent-Replayed: true, so it does not start a new run, and its result URL returns the same 400 (its status URL answers 200 with error\_type invalid\_input). Where other public https URLs are accepted, if that resubmit also fails with 400, the image itself is the problem (for example it is not a supported image, or its image size header is not within the first 2 MiB). Where they are not, the same uploaded image fails with a 5xx (500 internal\_error on Comfy Router) instead of that 400, and the image is still the problem, so uploading it again does not help. Only the first 2 MiB of each image is read to find its size, so an image whose size information cannot be read inside that window (such as a JPEG with over 2 MiB of embedded metadata, or a paletted PNG whose transparency data, or with none the start of its first image-data chunk, sits past 2 MiB, such as after over 2 MiB of text or color-profile chunks) is rejected with 400 saying its image size header is not within the first 2 MiB, uploaded or not; re-save it without the large metadata, or save a paletted PNG as a non-paletted PNG. Send an internationalized host in its ASCII (punycode) form; a non-ASCII host name is rejected as not existing. Omit for text-to-image.

**model** `string`

berry (default, quality) or jam (speed).

**negative\_prompt** `string`

**prompt** `string` *required*

What to generate. With image\_urls, the editing instruction; describe what should change and what should stay the same.

**regional\_edit** `boolean`

Set true for a local edit that keeps the rest of the image. Needs model berry and at least one image in image\_urls.

**resolution** `string` *required*

1k or 2k.

**seed** `integer`

**thinking\_mode** `string`

fast (default), high or ultra. High and ultra plan complex edits in more detail and take longer. Ultra needs resolution 2k.

Generated from the schema Router serves at `GET /v2/models/krea/krea-3/openapi.json`, the same document it validates a call against before the request reaches the provider.

### Output

**completed\_at** `string (date-time)` *required*

Format: `date-time`

**created\_at** `string (date-time)` *required*

Format: `date-time`

**error** `object`

Set only when status is failed. A cancelled job carries none.

**error.code** `string` *required*

Why the job failed: content\_policy, invalid\_request, validation\_failed, model\_unavailable, insufficient\_balance, timeout, auto\_cancelled, provider\_error, internal or node\_app\_node\_failed. Treat an unknown code as internal.

**error.message** `string`

Optional. Free-form provider text for provider\_error and internal.

**error.param** `string`

The request parameter to change, present with invalid\_request and validation\_failed.

**job\_id** `string (uuid)` *required*

Format: `uuid`

**result** `object` *required*

The finished generation. Not nullable here, unlike on `KreaJob`: a terminal job whose `result` carries no `urls` is answered as a Comfy Router error, so a `200` always carries it.

**result.style\_id** `string`

Set by loraTraining jobs rather than by a generation; a `200` for these models carries `urls`.

**result.urls** `string (uri)[]` *required*

The generated images, as downloadable links. At least one, because a `completed` job with an empty `urls` is `success_without_output` and never reaches this document.

**status** `string` *required*

Always `completed` on this document: it is the only status Router reports as a success, and Krea's vocabulary is matched without a case fold.

Possible values: `completed`

## Examples

### Input

```json theme={null}
{
  "prompt": "A ceramic coffee mug on a clean studio background",
  "resolution": "1k"
}
```

### Output

```json theme={null}
{
  "completed_at": "2027-01-01T00:00:37Z",
  "created_at": "2027-01-01T00:00:00Z",
  "job_id": "7f1c2e84-5b90-4a37-8d61-2c0f9ab4e153",
  "result": {
    "urls": [
      "https://example.invalid/krea/krea-2/generated.png"
    ]
  },
  "status": "completed"
}
```

## Before you ship

The SDKs create an `Idempotency-Key` and reuse it for automatic retries. For manual retries, reuse the original key. Router can hold the connection for up to 10 minutes.

When a request fails, Router sends an `X-Comfy-Error-Type` response header explaining why. A `422` means Router rejected the input before calling the provider, and a `413` means the request body was larger than Router accepts. Download generated assets promptly because [result URLs can expire](https://docs.comfy.org/development/comfy-router/reference.md#result-assets).

Any size limit named in a field description above is the provider's own bound on that field, quoted from the provider's specification. Router applies a separate cap to the whole request body, which base64-encoded media counts against: see [request body size](https://docs.comfy.org/development/comfy-router/limitations.md#request-bodies-are-capped).

This page documents one partner model called through Comfy Router. The same `comfy-sdk` / `@comfyorg/sdk` package also ships a second client, for running a whole ComfyUI workflow graph on Comfy Cloud: `Comfy(api_key=...)` / `new Comfy({ apiKey })`, with `client.workflows`, `client.assets` and `client.jobs`. See [Comfy SDKs](https://docs.comfy.org/development/api-development/sdks.md).

> [card] [Headers](https://docs.comfy.org/development/comfy-router/headers.md)
>
> Authentication, idempotency, request IDs, error buckets, retry pacing, spend limits.

> [card] [Using the Router API](https://docs.comfy.org/development/comfy-router/api.md)
>
> Model discovery, validation errors, retries, and billing.

> [card] [Limitations](https://docs.comfy.org/development/comfy-router/limitations.md)
>
> What Router does not do today, and what to use instead.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.