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

Shashank Agarwal

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

## Overview
This API runs FLUX.2 [klein] 9B from Black Forest Labs, a 4-step distilled version of FLUX.2 [klein] that Black Forest Labs describes as a foundation model for maximum flexibility and control. 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`)
- `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:** "Make it a bright sunny afternoon with a clear blue sky, keep the woman, her yellow raincoat and the sign unchanged"

Settings: `aspect_ratio` "match_input_image". All other inputs were left at their defaults (`output_megapixels` "1", `go_fast` false, `output_format` "jpg").

**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 bright sunny afternoon with a clear blue sky, with the woman, her yellow raincoat and the sign unchanged](https://blog.api.market/wp-content/uploads/2026/10/flux-2-klein-9b-output-api-market.jpg)

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.002 per API unit.
- **Output image**: 10 units per output megapixel, so $0.02 per output megapixel. The `output_megapixels` input sets the output size.
- **Input images**: each input megapixel counts as 0.13 of an output megapixel, so 1.3 units ($0.0026) per input megapixel.
- Output and input units are added together and rounded up to a whole unit per request.
- Text-to-image (no input images) by `output_megapixels` setting:
  - "0.25": 2.5 units, billed as 3 units = $0.006
  - "0.5": 5 units = $0.01
  - "1" (default): 10 units = $0.02
  - "2": 20 units = $0.04
  - "4": 40 units = $0.08
- **Worked example (editing)**: a 1 megapixel output with one 1 megapixel input image is (1 + 0.13) x 10 = 11.3 units, billed as 12 units = $0.024.
- 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/fast-image-gen-edit-black-forest-labs-flux-2-klein-9b`

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

**Request Example:**

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-image-gen-edit-black-forest-labs-flux-2-klein-9b/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "963f7b2c4aa2bc7e6377b95759dcf3a21cf175f6e8b0d8c1efe7bf6c8a23b690",
    "input": {
      "prompt": "Make it a bright sunny afternoon with a clear blue sky, keep the woman, her yellow raincoat and the sign unchanged",
      "images": ["https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"],
      "aspect_ratio": "match_input_image"
    }
  }'
```

**Response (201 Created):**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "963f7b2c4aa2bc7e6377b95759dcf3a21cf175f6e8b0d8c1efe7bf6c8a23b690",
  "status": "starting",
  "created_at": "2026-10-12T10:37:05.471Z"
}
```

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

**Request Example:**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-image-gen-edit-black-forest-labs-flux-2-klein-9b/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-9b-output-api-market.jpg"
  ],
  "error": null,
  "created_at": "2026-10-12T10:37:05.471Z",
  "started_at": "2026-10-12T10:37:06.000Z",
  "completed_at": "2026-10-12T10:37:16.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/fast-image-gen-edit-black-forest-labs-flux-2-klein-9b";

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: "963f7b2c4aa2bc7e6377b95759dcf3a21cf175f6e8b0d8c1efe7bf6c8a23b690",
      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: "Make it a bright sunny afternoon with a clear blue sky, keep the woman, her yellow raincoat and the sign unchanged",
  images: ["https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"],
  aspect_ratio: "match_input_image"
}).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/fast-image-gen-edit-black-forest-labs-flux-2-klein-9b"

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": "963f7b2c4aa2bc7e6377b95759dcf3a21cf175f6e8b0d8c1efe7bf6c8a23b690", "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": "Make it a bright sunny afternoon with a clear blue sky, keep the woman, her yellow raincoat and the sign unchanged",
    "images": ["https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"],
    "aspect_ratio": "match_input_image"
})
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/fast-image-gen-edit-black-forest-labs-flux-2-klein-9b/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "963f7b2c4aa2bc7e6377b95759dcf3a21cf175f6e8b0d8c1efe7bf6c8a23b690",
    "input": {
      "prompt": "Make it a bright sunny afternoon with a clear blue sky, keep the woman, her yellow raincoat and the sign unchanged",
      "images": ["https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"],
      "aspect_ratio": "match_input_image"
    }
  }'

# Step 2: Check prediction status (replace {id} with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-image-gen-edit-black-forest-labs-flux-2-klein-9b/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 | none | 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. Also sets the price (see Pricing). |
| 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, at a lower rate than the output: each input megapixel counts as 0.13 of an output megapixel (1.3 units, $0.0026). The total is rounded up to a whole unit per request.

- **How do I lower the cost of a request?**
  Use a smaller `output_megapixels` value. A 0.5 megapixel text-to-image request costs $0.01, half of the default 1 megapixel.

- **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] 9B by Black Forest Labs, a 4-step distilled model. $0.02 per output megapixel.