Name: FLUX.1 Kontext [dev] LoRA Image Editing API
Brand: magicapi
SKU: api-magicapi-image-editing-lora-model-black-forest-labs-flux-kontext-dev-lora
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎨 LoRA Image Editing API (FLUX.1 Kontext [dev] LoRA)

## Overview
FLUX.1 Kontext [dev] LoRA is an image editing model from Black Forest Labs that runs a LoRA fine-tune of FLUX.1 Kontext [dev]. You point `lora_weights` at a LoRA file, give an instruction in `prompt`, and the model edits your `input_image` in the style or with the concept the LoRA was trained on.

Leave `input_image` empty to generate a new image from the prompt instead. Each request returns the URL of one image.

## Features
- **Bring your own LoRA**: set `lora_weights` to the location of the LoRA weights, for example a URL to a `.safetensors` file, and control its effect with `lora_strength` (default `1`).
- **Instruction-based editing**: describe the change in `prompt` and pass the image to edit as `input_image` (jpeg, png, gif or webp).
- **Text-to-image**: leave `input_image` blank to generate from the prompt alone.
- **Aspect ratios**: `match_input_image` (default), `1:1`, `16:9`, `21:9`, `3:2`, `2:3`, `4:5`, `5:4`, `3:4`, `4:3`, `9:16`, `9:21`.
- **Output size**: about `1` megapixel (default) or `0.25` megapixels.
- **Quality controls**: `num_inference_steps` (4 to 50, default 30), `guidance` (0 to 10, default 2.5) and `go_fast` (default `true`, which may slightly lower quality on difficult prompts).
- **Output format**: `webp` (default), `jpg` or `png`, with `output_quality` from 0 to 100 for lossy formats.

## Use Cases
1. **Consistent visual styles**: apply a trained style LoRA (for example a retro game look) to many photos with the same instruction.
2. **Brand or character LoRAs**: place a concept your LoRA was trained on into new scenes.
3. **Testing a fine-tune**: run a LoRA you trained against sample images before using it in production.
4. **Restyling product and marketing images**: change the look of an existing image while keeping its composition.

## Visual Examples
### Example Input
Image (`input_image`):

![Input image: a woman in a yellow raincoat on a rainy street under a pink neon glow](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp)

Prompt: "Render this image like a PS1 game, with low-poly shapes, blocky pixelated textures and a slight fog (no UI)"

LoRA (`lora_weights`): `https://huggingface.co/fofr/flux-kontext-dev-ps1-lora/resolve/main/flux-kontext-dev-ps1-lora.safetensors`, a public PS1-style LoRA, with `lora_strength` `1`. All other fields were left at their defaults.

### Example Output
![FLUX.1 Kontext dev LoRA output: the rainy neon street scene re-rendered in a low-poly PS1 game style](https://blog.api.market/wp-content/uploads/2026/10/flux-kontext-dev-lora-output-api-market.webp)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text description of what you want to generate, or the instruction on how to edit the given image |
| `input_image` | string (URL) | No | none |  | Image to use as reference for image-to-image generation. Leave blank for text-to-image generation. Must be jpeg, png, gif or webp |
| `lora_weights` | string | No | none |  | Path to the LoRA weights, for example a URL to a `.safetensors` file |
| `lora_strength` | number | No | `1` |  | Strength of the LoRA |
| `aspect_ratio` | string | No | `match_input_image` | `1:1`, `16:9`, `21:9`, `3:2`, `2:3`, `4:5`, `5:4`, `3:4`, `4:3`, `9:16`, `9:21`, `match_input_image` | Aspect ratio of the generated image. Use `match_input_image` to match the aspect ratio of the input image |
| `megapixels` | string | No | `1` | `1`, `0.25` | Approximate number of megapixels for the generated image |
| `num_inference_steps` | integer | No | `30` | 4 to 50 | Number of inference steps |
| `guidance` | number | No | `2.5` | 0 to 10 | Guidance scale for generation |
| `seed` | integer | No | none |  | Random seed for reproducible generation. Leave blank for random |
| `output_format` | string | No | `webp` | `webp`, `jpg`, `png` | Output image format |
| `output_quality` | integer | No | `80` | 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 the NSFW safety checker |
| `go_fast` | boolean | No | `true` |  | Make the model go fast; output quality may be slightly degraded for more difficult prompts |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.04 per API unit.
- **1 API unit = 1 output image.** Each request returns one image, so each successful request costs $0.04, including the example above.
- Every input setting (LoRA, steps, megapixels, output format) is billed the same.
- **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/image-editing-lora-model-black-forest-labs-flux-kontext-dev-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/image-editing-lora-model-black-forest-labs-flux-kontext-dev-lora/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "50c10b8f14af90fda0a4bf3bbfdda263ddb0f2b3e32e4735dcc6ee7156d7ed6f",
    "input": {
      "prompt": "Render this image like a PS1 game, with low-poly shapes, blocky pixelated textures and a slight fog (no UI)",
      "input_image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
      "lora_weights": "https://huggingface.co/fofr/flux-kontext-dev-ps1-lora/resolve/main/flux-kontext-dev-ps1-lora.safetensors",
      "lora_strength": 1
    }
  }'
```

Response (201 Created):
```json
{
  "id": "p7gextwnmdrnc0d17fq8jx22r8",
  "version": "50c10b8f14af90fda0a4bf3bbfdda263ddb0f2b3e32e4735dcc6ee7156d7ed6f",
  "status": "starting",
  "created_at": "2026-10-14T19:40:54.215Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-editing-lora-model-black-forest-labs-flux-kontext-dev-lora/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "p7gextwnmdrnc0d17fq8jx22r8",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/flux-kontext-dev-lora-output-api-market.webp",
  "error": null,
  "created_at": "2026-10-14T19:40:54.215Z",
  "started_at": "2026-10-14T19:40:55.215Z",
  "completed_at": "2026-10-14T19:41:10.215Z"
}
```

`output` is a single URL string pointing to the edited image, in the format set by `output_format`.

### 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 a `num_inference_steps` outside 4 to 50.
- **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 the LoRA file at `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/image-editing-lora-model-black-forest-labs-flux-kontext-dev-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: "50c10b8f14af90fda0a4bf3bbfdda263ddb0f2b3e32e4735dcc6ee7156d7ed6f", 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": "Render this image like a PS1 game, with low-poly shapes, blocky pixelated textures and a slight fog (no UI)",
  "input_image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
  "lora_weights": "https://huggingface.co/fofr/flux-kontext-dev-ps1-lora/resolve/main/flux-kontext-dev-ps1-lora.safetensors",
  "lora_strength": 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/image-editing-lora-model-black-forest-labs-flux-kontext-dev-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": "50c10b8f14af90fda0a4bf3bbfdda263ddb0f2b3e32e4735dcc6ee7156d7ed6f", "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": "Render this image like a PS1 game, with low-poly shapes, blocky pixelated textures and a slight fog (no UI)",
    "input_image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
    "lora_weights": "https://huggingface.co/fofr/flux-kontext-dev-ps1-lora/resolve/main/flux-kontext-dev-ps1-lora.safetensors",
    "lora_strength": 1
}))
```

## FAQ
- **Where does the LoRA come from?**
  - You supply it. Set `lora_weights` to a location the model can download, such as a public URL to a `.safetensors` file. The example uses a public PS1-style LoRA.
- **How do I make the LoRA effect weaker or stronger?**
  - Change `lora_strength`. The default is `1`.
- **Can I generate an image without an input image?**
  - Yes. Leave `input_image` blank and the model generates an image from `prompt`.
- **Does a higher step count or a larger image cost more?**
  - No. Every request returns one image and costs $0.04, whatever `num_inference_steps`, `megapixels` or `output_format` you choose.
- **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, 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.


Edit or generate images with FLUX.1 Kontext [dev] from Black Forest Labs using LoRA weights you supply. $0.04 per image, pay as you go.