Name: FLUX.1 Krea [dev] Photorealistic Text-to-Image API
Brand: magicapi
SKU: api-magicapi-photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev
Availability: InStock
Author: API Market

Shashank Agarwal

# 📷 Photorealistic Text-to-Image Generator API (FLUX.1 Krea [dev])

## Overview
This API runs FLUX.1 Krea [dev], an opinionated text-to-image model from Black Forest Labs made in collaboration with Krea. It is tuned for photorealism and aims for images that avoid the oversaturated "AI look". Send a text prompt to generate up to 4 images, or add an input image to use image-to-image mode.

## Features
- Text-to-image generation tuned for photorealistic results
- Image-to-image mode with an input `image`; `prompt_strength` controls how much of the input image is kept
- 1 to 4 images per request (`num_outputs`)
- 11 aspect ratios from 21:9 to 9:21; in image-to-image mode the output matches the input image's aspect ratio
- Output size of about 1 megapixel (default) or 0.25 megapixels (`megapixels`)
- Control over `guidance` and `num_inference_steps`
- `go_fast` (on by default) runs an fp8 quantized model for speed; turn it off to run the original bf16 model
- `seed` for reproducible generation (only when `go_fast` is off)
- Output as webp (default), jpg or png, with adjustable quality
- Safety checker on by default (`disable_safety_checker` turns it off)

## Use Cases
1. **Portrait and lifestyle photography**: generate natural-looking people and scenes for articles, ads and social posts.
2. **Product and scene mockups**: describe a setting and get a photo-style image for a listing or a pitch.
3. **Restyling a photo**: pass an input image with a prompt and tune `prompt_strength` to decide how far the result moves from the original.
4. **Picking the best shot**: request up to 4 images at once and choose one.
5. **Quick drafts**: generate 0.25 megapixel images to try prompts before switching to 1 megapixel.

## Visual Examples
### Text-to-image
**Prompt:** "Photorealistic portrait of an elderly fisherman mending a net on a wooden dock at golden hour, natural skin texture, 35mm film look"

All other inputs were left at their defaults (`aspect_ratio` "1:1", `megapixels` "1", `num_outputs` 1, `output_format` "webp").

![Photorealistic portrait of an elderly fisherman mending a net on a wooden dock at golden hour](https://blog.api.market/wp-content/uploads/2026/10/flux-krea-dev-output-api-market.webp)

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.032 per API unit.
- **1 API unit** = 1 output image. A request that returns several images (`num_outputs` up to 4) is billed for each one, so 4 images cost $0.128.
- Failed or cancelled predictions are not billed.
- GET requests to check prediction status are free and don't count toward API unit usage.
- No monthly subscription fee.

## API Documentation

### Base URL
All API requests should be made to: `https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev`

### Authentication
Include your api.market API key in the request header:

```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:

1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (the image URLs are in `output`), `failed` or `canceled` (see `error`).

Suggested client settings:
- Poll every 1 second
- Give up after 600 seconds (10 minutes)

### Endpoints
#### `POST /api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev/predictions`
Create a prediction.

**Request Example:**

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "9d7a7c510de5b6bab1b183a9ed61cee5416ea3b4ab0bd644047780c4ef115662",
    "input": {
      "prompt": "Photorealistic portrait of an elderly fisherman mending a net on a wooden dock at golden hour, natural skin texture, 35mm film look"
    }
  }'
```

**Response (201 Created):**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "9d7a7c510de5b6bab1b183a9ed61cee5416ea3b4ab0bd644047780c4ef115662",
  "status": "starting",
  "created_at": "2026-10-11T19:03:32.810Z"
}
```

#### `GET /api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev/predictions/{id}`
Check prediction status and get the result.

**Request Example:**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response Example (200 OK):**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/10/flux-krea-dev-output-api-market.webp"
  ],
  "error": null,
  "created_at": "2026-10-11T19:03:32.810Z",
  "started_at": "2026-10-11T19:03:33.000Z",
  "completed_at": "2026-10-11T19:03:40.000Z"
}
```

`output` is an array with one image URL per requested output.

### Status Codes
- **201 Created**: prediction created (POST). This is the normal success response.
- **200 OK**: prediction found (GET). Check `status` for progress.
- **400 Bad Request**: invalid input parameters or malformed request
- **401 Unauthorized**: missing or invalid API key
- **404 Not Found**: prediction not found
- **429 Too Many Requests**: rate limit exceeded
- **500 Internal Server Error**: server-side error

### Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Implementation Guide

### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev";

async function createAndWaitForPrediction(inputData) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({
      version: "9d7a7c510de5b6bab1b183a9ed61cee5416ea3b4ab0bd644047780c4ef115662",
      input: inputData
    })
  });

  // 201 Created is the normal success response
  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return await pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000;
  const POLL_INTERVAL = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  prompt: "Photorealistic portrait of an elderly fisherman mending a net on a wooden dock at golden hour, natural skin texture, 35mm film look"
}).then((imageUrls) => console.log(imageUrls));
```

### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY,
    }
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={
            "version": "9d7a7c510de5b6bab1b183a9ed61cee5416ea3b4ab0bd644047780c4ef115662",
            "input": input_data,
        },
    )

    # 201 Created is the normal success response
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])

def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)
        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()
        if prediction["status"] == "succeeded":
            return prediction["output"]
        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")

image_urls = create_and_wait_for_prediction({
    "prompt": "Photorealistic portrait of an elderly fisherman mending a net on a wooden dock at golden hour, natural skin texture, 35mm film look"
})
print(image_urls)
```

### cURL
```bash
# Step 1: Create a prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "9d7a7c510de5b6bab1b183a9ed61cee5416ea3b4ab0bd644047780c4ef115662",
    "input": {
      "prompt": "Photorealistic portrait of an elderly fisherman mending a net on a wooden dock at golden hour, natural skin texture, 35mm film look"
    }
  }'

# Step 2: Check prediction status (replace {id} with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/magicapi/photorealistic-text-to-image-generator-black-forest-labs-flux-krea-dev/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## Input Parameters
| Parameter | Type | Default | Allowed Values | Required | Description |
|-----------|------|---------|----------------|----------|-------------|
| prompt | string | none | Any text | Yes | Prompt for the generated image. |
| aspect_ratio | string | "1:1" | "1:1", "16:9", "21:9", "3:2", "2:3", "4:5", "5:4", "3:4", "4:3", "9:16", "9:21" | No | Aspect ratio for the generated image. |
| image | string (URL) | null | Image URL | No | Input image for image-to-image mode. The aspect ratio of the output will match this image. |
| prompt_strength | number | 0.8 | 0 to 1 | No | Prompt strength when using image-to-image. 1.0 corresponds to full destruction of information in the image. |
| num_outputs | integer | 1 | 1 to 4 | No | Number of outputs to generate. Each output is billed as one image. |
| num_inference_steps | integer | 28 | 1 to 50 | No | Number of denoising steps. Recommended range is 28 to 50; fewer steps are faster but lower quality. |
| guidance | number | 4.5 | 0 to 10 | No | Guidance for the generated image. Lower values can give more realistic images; good values to try are 2, 2.5, 3 and 3.5. |
| seed | integer | null | Any integer | No | Random seed. Set for reproducible generation. |
| output_format | string | "webp" | "webp", "jpg", "png" | No | Format of the output images. |
| output_quality | integer | 80 | 0 to 100 | No | Quality when saving the output images. 100 is best quality, 0 is lowest. Not relevant for png outputs. |
| disable_safety_checker | boolean | false | true, false | No | Disable the safety checker for generated images. |
| go_fast | boolean | true | true, false | No | Run faster predictions with a model optimized for speed (currently fp8 quantized); disable to run in original bf16. Outputs are not deterministic when this is enabled, even if you set a seed. |
| megapixels | string | "1" | "1", "0.25" | No | Approximate number of megapixels for the generated image. |

## FAQ
- **How do I authenticate with the API?**
  Send your api.market API key in the `x-api-market-key` request header.

- **Why does the POST return 201 instead of 200?**
  201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until the status is `succeeded`, `failed` or `canceled`.

- **How do I get the same image twice?**
  Set `seed` and turn `go_fast` off. With `go_fast` on, outputs are not deterministic even with a seed.

- **How much does a request cost?**
  $0.032 per output image. The default `num_outputs` of 1 costs $0.032; 4 outputs cost $0.128.

- **Do I get charged for failed or cancelled requests?**
  No, failed or cancelled predictions are not billed.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Photorealistic text-to-image with FLUX.1 Krea [dev] by Black Forest Labs and Krea. Image-to-image mode, up to 4 images per request, $0.032 per image.