Name: FLUX.2 [klein] 4B Fast Image Generation & Editing API
Brand: magicapi
SKU: api-magicapi-ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b
Availability: InStock
Author: API Market

Shashank Agarwal

# ⚡ Fast Image Generation & Editing API (FLUX.2 [klein] 4B)

## Overview
This API runs FLUX.2 [klein] 4B from Black Forest Labs, a fast image generation and editing model. Black Forest Labs distilled it to 4 steps for production and near real-time use. Send a text prompt to generate an image, or add up to 5 input images and describe how to change them.

## Features
- Text-to-image generation from a prompt
- Image editing and image-to-image generation with up to 5 input images (`images`)
- 11 aspect ratios, plus `match_input_image` to match the first input image
- Output size of 0.25, 0.5, 1 (default), 2 or 4 megapixels (`output_megapixels`)
- Optional `go_fast` mode with additional optimizations (off by default)
- `seed` for reproducible generation
- Output as jpg (default), webp or png, with adjustable quality
- Safety checker on by default (`disable_safety_checker` turns it off)

## Use Cases
1. **Photo edits from a sentence**: change the weather, time of day or background of a photo while keeping the subject.
2. **Product and marketing images**: generate visuals for listings, banners and social posts from a prompt.
3. **Interactive apps**: the 4-step model suits features where users wait on the result, such as previews and quick iterations.
4. **Multi-image composition**: combine elements from up to 5 reference images in one request.
5. **Low-cost drafts**: generate small (0.25 or 0.5 megapixel) images to explore ideas before producing larger ones.

## Visual Examples
### Image editing
**Prompt:** "Turn this scene into a snowy winter night with snowflakes falling, keep the woman and the neon sign unchanged"

Settings: `aspect_ratio` "match_input_image", `output_megapixels` "1".

**Input image:** [View the input image](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp)

**Output:**

![The input scene turned into a snowy winter night, with the woman and the neon sign unchanged](https://blog.api.market/wp-content/uploads/2026/10/flux-2-klein-4b-output-api-market.webp)

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0013 per API unit.
- **1 API unit** = 1 megapixel of output image (a 1024x1024 image counts as 1 megapixel).
- Input image megapixels are billed the same way, at the same $0.0013 per megapixel.
- The megapixels of the output image and every input image are added together and rounded up to whole units per request. For example, a request whose images add up to 2.3 megapixels bills 3 units ($0.0039).
- 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/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b`

### 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/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b/predictions`
Create a prediction.

**Request Example:**

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "8e9c42d77b10a2a41af823ac4500f7545be6ebc4e745830fc3f3de10de200542",
    "input": {
      "prompt": "Turn this scene into a snowy winter night with snowflakes falling, keep the woman and the neon sign unchanged",
      "images": [
        "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
      ],
      "aspect_ratio": "match_input_image",
      "output_megapixels": "1"
    }
  }'
```

**Response (201 Created):**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "8e9c42d77b10a2a41af823ac4500f7545be6ebc4e745830fc3f3de10de200542",
  "status": "starting",
  "created_at": "2026-10-11T19:01:07.888Z"
}
```

#### `GET /api/v1/magicapi/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b/predictions/{id}`
Check prediction status and get the result.

**Request Example:**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b/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-2-klein-4b-output-api-market.webp"
  ],
  "error": null,
  "created_at": "2026-10-11T19:01:07.888Z",
  "started_at": "2026-10-11T19:01:08.000Z",
  "completed_at": "2026-10-11T19:01:10.000Z"
}
```

`output` is an array of image URLs.

### 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/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b";

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: "8e9c42d77b10a2a41af823ac4500f7545be6ebc4e745830fc3f3de10de200542",
      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: "Turn this scene into a snowy winter night with snowflakes falling, keep the woman and the neon sign unchanged",
  images: ["https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"],
  aspect_ratio: "match_input_image",
  output_megapixels: "1"
}).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/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b"

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": "8e9c42d77b10a2a41af823ac4500f7545be6ebc4e745830fc3f3de10de200542",
            "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": "Turn this scene into a snowy winter night with snowflakes falling, keep the woman and the neon sign unchanged",
    "images": ["https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"],
    "aspect_ratio": "match_input_image",
    "output_megapixels": "1",
})
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/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "8e9c42d77b10a2a41af823ac4500f7545be6ebc4e745830fc3f3de10de200542",
    "input": {
      "prompt": "Turn this scene into a snowy winter night with snowflakes falling, keep the woman and the neon sign unchanged",
      "images": [
        "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
      ],
      "aspect_ratio": "match_input_image",
      "output_megapixels": "1"
    }
  }'

# Step 2: Check prediction status (replace {id} with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-image-gen-edit-black-forest-labs-flux-2-klein-4b/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 | Text prompt for image generation. |
| images | array of URLs | [] | Up to 5 image URLs (jpeg, png, gif or webp) | No | Input images for image-to-image generation and editing. |
| aspect_ratio | string | "1:1" | "1:1", "16:9", "9:16", "3:2", "2:3", "4:3", "3:4", "5:4", "4:5", "21:9", "9:21", "match_input_image" | No | Aspect ratio for the generated image. "match_input_image" matches the aspect ratio of the first input image. |
| output_megapixels | string | "1" | "0.25", "0.5", "1", "2", "4" | No | Resolution of the output image in megapixels. |
| seed | integer | null | Any integer | No | Random seed. Set for reproducible generation. |
| go_fast | boolean | false | true, false | No | Run faster predictions with additional optimizations. |
| output_format | string | "jpg" | "webp", "jpg", "png" | No | Format of the output images. |
| output_quality | integer | 95 | 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. |

## 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 edit an image?**
  Put the image URL in `images` (up to 5) and describe the change in `prompt`. Set `aspect_ratio` to "match_input_image" to keep the original proportions.

- **Do input images cost extra?**
  Yes. Input image megapixels are billed at the same $0.0013 per megapixel as the output, added to the output megapixels and rounded up to whole units per request.

- **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.


Generate and edit images with FLUX.2 [klein] 4B by Black Forest Labs, a 4-step distilled model for near real-time use. $0.0013 per megapixel.