---
title: "Use Krea 3 with Comfy Router"
description: "Call krea/krea-3 through Comfy Router: endpoint, request shape and the response Router returns."
sidebarTitle: "Krea 3"
---

{/* GENERATED FILE. Generated from router-schemas/krea/krea-3.json by `pnpm code-pages:gen`. */}

import RouterCodeFooter from "/snippets/comfy-router/model-code-footer.mdx";

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`

<Tabs defaultTabIndex={1}>
  <Tab title="Wait for the result">
<CodeGroup>
```python Python
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
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
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\"}"
```
</CodeGroup>
  </Tab>
  <Tab title="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](/development/comfy-router/queue) walks through status, cancellation and collection.

<CodeGroup>
```python Python
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
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
# 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"
```
</CodeGroup>
  </Tab>
</Tabs>

## Schema

### Input

<ParamField body="aspect_ratio" type="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.
</ParamField>

<ParamField body="image_urls" type="string[]">
  Input image URLs, up to 8. 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; where they are, any public https image URL is accepted, and a URL that is malformed or not https is rejected with 400. 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. 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. Omit for text-to-image.
</ParamField>

<ParamField body="model" type="string">
  berry (default, quality) or jam (speed).
</ParamField>

<ParamField body="negative_prompt" type="string">
   
</ParamField>

<ParamField body="prompt" type="string" required>
  What to generate. With image_urls, the editing instruction; describe what should change and what should stay the same.
</ParamField>

<ParamField body="regional_edit" type="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.
</ParamField>

<ParamField body="resolution" type="string" required>
  1k or 2k.
</ParamField>

<ParamField body="seed" type="integer">
   
</ParamField>

<ParamField body="thinking_mode" type="string">
  fast (default), high or ultra. High and ultra plan complex edits in more detail and take longer. Ultra needs resolution 2k.
</ParamField>

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

<ResponseField name="completed_at" type="string (date-time)" required>
  Format: `date-time`
</ResponseField>

<ResponseField name="created_at" type="string (date-time)" required>
  Format: `date-time`
</ResponseField>

<ResponseField name="job_id" type="string (uuid)" required>
  Format: `uuid`
</ResponseField>

<ResponseField name="result" type="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.
</ResponseField>

<ResponseField name="result.style_id" type="string">
  Set by loraTraining jobs rather than by a generation; a `200` for these models carries `urls`.
</ResponseField>

<ResponseField name="result.urls" type="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.
</ResponseField>

<ResponseField name="status" type="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`
</ResponseField>

## Examples

### Input

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

### Output

```json
{
  "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"
}
```


<RouterCodeFooter />