Name: FLUX.2 [klein] 4B Base LoRA Image Generation API
Brand: magicapi
SKU: api-magicapi-fast-fine-tuned-lora-inference-black-forest-labs-flux-2-klein-4b-base-lora
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎨 LoRA Image Generation API (FLUX.2 [klein] 4B Base LoRA)

## Overview
FLUX.2 [klein] 4B Base LoRA runs the 4B base model of FLUX.2 [klein] from Black Forest Labs with LoRA weights you supply. Its developer describes it as a version of FLUX.2 [klein] 4B-base that supports fast inference with fine-tuned LoRAs.

Send a text `prompt` for text-to-image, or add up to 5 input images in `images` for image-to-image generation. Point `lora_weights` at one or more LoRA files to apply a style, character or concept you trained. This API runs inference only; it does not train LoRAs. Each request returns an array with the URL of one image.

## Features
- **Bring your own LoRA**: `lora_weights` takes a list of LoRA URLs, for example a public Hugging Face file URL or a `.safetensors` file you host yourself. ComfyUI and native Flux Klein format LoRAs are supported; ComfyUI LoRAs are converted automatically.
- **Several LoRAs per request**: set a strength for each LoRA with `lora_scales`. The list must have the same length as `lora_weights`; each scale defaults to 1.0.
- **Text-to-image and image-to-image**: a prompt alone, or a prompt plus up to 5 input images (jpeg, png, gif or webp).
- **Output size**: `output_megapixels` of `0.25`, `0.5`, `1` (default), `2` or `4`.
- **Aspect ratios**: `1:1` (default), `16:9`, `9:16`, `3:2`, `2:3`, `4:3`, `3:4`, `5:4`, `4:5`, `21:9`, `9:21`, or `match_input_image` to follow the first input image.
- **Seed**: set a seed to reproduce a result.
- **Output formats**: `jpg` (default), `png` or `webp`, with `output_quality` from 0 to 100 for jpg and webp.

## Use Cases
1. **Testing a LoRA you trained**: run a LoRA trained for the FLUX.2 [klein] 4B base model against your own prompts.
2. **Consistent visual styles**: apply one style LoRA to many prompts so a set of images shares the same look.
3. **Characters and products**: place a character or product your LoRA was trained on into new scenes.
4. **Image-to-image with a LoRA**: combine reference images in `images` with a LoRA style.

## Visual Examples
### Example Input
Prompt: "A cozy reading nook by a rain-streaked window, a stack of books, a steaming mug and a small brass lamp, warm evening light, photographic."

`output_megapixels`: `1`. All other fields were left at their defaults (no LoRA, no input images, `aspect_ratio` `1:1`, `output_format` `jpg`). Because no LoRA was set, this output shows the base model on its own.

### Example Output
![FLUX.2 klein 4B Base LoRA output generated from the reading nook prompt above](https://blog.api.market/wp-content/uploads/2026/10/flux-2-klein-4b-base-lora-output-api-market.jpg)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for image generation. |
| `images` | array of URLs | No | `[]` |  | List of input images for image-to-image generation. Maximum 5 images. Must be jpeg, png, gif, or webp. |
| `aspect_ratio` | string | No | `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` | Aspect ratio for the generated image. Use 'match_input_image' to match the aspect ratio of the first input image. |
| `output_megapixels` | string | No | `1` | `0.25`, `0.5`, `1`, `2`, `4` | Resolution of the output image in megapixels |
| `seed` | integer | No | none |  | Random seed. Set for reproducible generation |
| `lora_weights` | array of strings | No | none |  | LoRA weights as a list of URLs. Supports ComfyUI and native Flux Klein format LoRAs. ComfyUI LoRAs are automatically converted. |
| `lora_scales` | array of numbers | No | none |  | Scales for each LoRA as a list of floats. Must match the number of lora_weights. Defaults to 1.0 for each if not provided. |
| `output_format` | string | No | `jpg` | `webp`, `jpg`, `png` | Format of the output images |
| `output_quality` | integer | No | `95` | 0 to 100 | Quality when saving the output images, from 0 to 100. 100 is best quality, 0 is lowest quality. Not relevant for .png outputs. |
| `disable_safety_checker` | boolean | No | `false` |  | Disable safety checker for generated images. |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.001 per API unit.
- **How units are counted**: units = (output megapixels + input megapixels x 0.5) x 24, rounded up once per request. Input megapixels are the total of every image in `images`. Each output image counts as at least 1 megapixel, so `0.25` and `0.5` cost the same as `1`.
- That works out to **$0.024 per output megapixel** and **$0.012 per megapixel of input images**.
- Output size is set by `output_megapixels`. With no input images:
  - `0.25`: 24 units, $0.024 (billed as 1 megapixel)
  - `0.5`: 24 units, $0.024 (billed as 1 megapixel)
  - `1` (default): 24 units, $0.024
  - `2`: 48 units, $0.048
  - `4`: 96 units, $0.096
- **Worked example with an input image**: `output_megapixels` `1` with one 1 megapixel input image is (1 + 1 x 0.5) x 24 = 36 units = $0.036.
- **The example above** (1 megapixel output, no input images) used 24 units and cost $0.024.
- LoRAs, aspect ratio, seed and output format do not change the price.
- **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 go to: `https://prod.api.market/api/v1/magicapi/fast-fine-tuned-lora-inference-black-forest-labs-flux-2-klein-4b-base-lora`

### Authentication
Send your api.market API key in the `x-api-market-key` 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` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-fine-tuned-lora-inference-black-forest-labs-flux-2-klein-4b-base-lora/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c8ca755d41dd4a19b8fe1f50247bc6b37c73ac5321af8277d97c5e66e803ecdc",
    "input": {
      "prompt": "A cozy reading nook by a rain-streaked window, a stack of books, a steaming mug and a small brass lamp, warm evening light, photographic.",
      "output_megapixels": "1"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "3s6qjan1ehrne0d17gebth787c",
  "version": "c8ca755d41dd4a19b8fe1f50247bc6b37c73ac5321af8277d97c5e66e803ecdc",
  "status": "starting",
  "created_at": "2026-10-14T20:31:11.883Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-fine-tuned-lora-inference-black-forest-labs-flux-2-klein-4b-base-lora/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "3s6qjan1ehrne0d17gebth787c",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/10/flux-2-klein-4b-base-lora-output-api-market.jpg"
  ],
  "error": null,
  "created_at": "2026-10-14T20:31:11.883Z",
  "started_at": "2026-10-14T20:31:12.883Z",
  "completed_at": "2026-10-14T20:31:18.883Z"
}
```

`output` is an array of URL strings, one per generated image. A request returns one image, so the array has one entry.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt` or an `output_megapixels` value that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

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

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why, for example when a file in `lora_weights` cannot be loaded. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-fine-tuned-lora-inference-black-forest-labs-flux-2-klein-4b-base-lora";

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

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

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

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

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

  while (Date.now() - startTime < maxTimeout) {
    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(pollInterval);
  }

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

createAndWaitForPrediction({
  "prompt": "A cozy reading nook by a rain-streaked window, a stack of books, a steaming mug and a small brass lamp, warm evening light, photographic.",
  "output_megapixels": "1"
}).then((output) => console.log(output));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/fast-fine-tuned-lora-inference-black-forest-labs-flux-2-klein-4b-base-lora"

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": "c8ca755d41dd4a19b8fe1f50247bc6b37c73ac5321af8277d97c5e66e803ecdc", "input": input_data},
    )

    if response.status_code != 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")

print(create_and_wait_for_prediction({
    "prompt": "A cozy reading nook by a rain-streaked window, a stack of books, a steaming mug and a small brass lamp, warm evening light, photographic.",
    "output_megapixels": "1"
}))
```

## FAQ
- **Where do the LoRA weights come from?**
  - You supply them. Put the URL of each LoRA file in `lora_weights`, for example a public Hugging Face file URL or your own hosted `.safetensors` file. Use LoRAs trained for the FLUX.2 [klein] 4B base model, in ComfyUI or native Flux Klein format. This API does not train LoRAs.
- **Can I combine several LoRAs?**
  - Yes. List them in `lora_weights` and give one strength per LoRA in `lora_scales`, in the same order. If you leave out `lora_scales`, every LoRA uses 1.0.
- **Can I run it without a LoRA?**
  - Yes. Leave out `lora_weights` and the base model runs on its own, as in the example above.
- **Do input images change the price?**
  - Yes. Each megapixel of input images in `images` adds 12 units ($0.012), on top of $0.024 per output megapixel. The total is rounded up once per request.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, check that every `lora_weights` URL is reachable, adjust the input and try again.

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


Run your own LoRAs on FLUX.2 [klein] 4B Base from Black Forest Labs: text-to-image and image-to-image with up to 5 input images. $0.024 per output megapixel.