Name: Text-to-Image API with LoRA (FLUX.1 [dev] LoRA)
Brand: magicapi
SKU: api-magicapi-text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ Text-to-Image API with LoRA Support (FLUX.1 [dev] LoRA)

## Overview
This API runs a version of FLUX.1 [dev], the text-to-image model from Black Forest Labs, that supports fast inference with fine-tuned LoRA weights. Send a prompt and, optionally, the LoRA weights to apply (a LoRA model ID, a HuggingFace or CivitAI URL, or a .safetensors URL). You can combine two LoRAs in one request and also start from an input image.

## Features
- Text-to-image generation from a prompt
- Load LoRA weights with `lora_weights` and a second LoRA with `extra_lora`, each with its own strength (`lora_scale`, `extra_lora_scale`)
- LoRA sources: model IDs (`<owner>/<model-name>`), HuggingFace URLs, CivitAI URLs, or .safetensors URLs, including signed URLs
- Image-to-image mode with `image` and `prompt_strength`
- 11 aspect ratios and an output size of about 1 megapixel (default) or 0.25 megapixel
- 1 to 4 images per request (`num_outputs`)
- `go_fast` mode (on by default) runs an fp8 quantized model; turn it off to run in original bf16
- Output as webp (default), jpg or png, with adjustable quality
- Safety checker on by default (`disable_safety_checker` turns it off)

## Use Cases
1. **Custom styles**: apply a style LoRA, such as the 80s cyberpunk LoRA in the example below, to every image you generate.
2. **Consistent characters or products**: use a LoRA fine-tuned on a person, mascot or product to keep it recognizable across images.
3. **Combining two LoRAs**: pair a subject LoRA with a style LoRA using `lora_weights` and `extra_lora`.
4. **Restyling an existing image**: pass `image` with a LoRA and a prompt, and set `prompt_strength` to control how much of the original is kept.

## Visual Examples
### Text-to-image with a LoRA
**Prompt:** "style of 80s cyberpunk, a portrait photo of a developer wearing headphones in front of a glowing terminal"

**LoRA:** `lora_weights` "fofr/flux-80s-cyberpunk". All other inputs were left at their defaults (`aspect_ratio` "1:1", `megapixels` "1", `num_outputs` 1, `output_format` "webp").

![A portrait in an 80s cyberpunk style of a developer wearing headphones in front of a glowing terminal](https://blog.api.market/wp-content/uploads/2026/10/flux-dev-lora-output-api-market.webp)

## 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. A request is billed for every image it returns (`num_outputs`):
  - 1 image (default): 1 unit = $0.04
  - 2 images: 2 units = $0.08
  - 3 images: 3 units = $0.12
  - 4 images: 4 units = $0.16
- 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/text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora`

### 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/text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora/predictions`
Create a prediction.

**Request Example:**

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "ae0d7d645446924cf1871e3ca8796e8318f72465d2b5af9323a835df93bf0917",
    "input": {
      "prompt": "style of 80s cyberpunk, a portrait photo of a developer wearing headphones in front of a glowing terminal",
      "lora_weights": "fofr/flux-80s-cyberpunk"
    }
  }'
```

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

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

**Request Example:**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora/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-dev-lora-output-api-market.webp"
  ],
  "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, one per image requested with `num_outputs`.

### 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/text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora";

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: "ae0d7d645446924cf1871e3ca8796e8318f72465d2b5af9323a835df93bf0917",
      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: "style of 80s cyberpunk, a portrait photo of a developer wearing headphones in front of a glowing terminal",
  lora_weights: "fofr/flux-80s-cyberpunk"
}).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/text-to-image-fast-fine-tuning-black-forest-labs-flux-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": "ae0d7d645446924cf1871e3ca8796e8318f72465d2b5af9323a835df93bf0917", "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": "style of 80s cyberpunk, a portrait photo of a developer wearing headphones in front of a glowing terminal",
    "lora_weights": "fofr/flux-80s-cyberpunk"
})
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/text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "ae0d7d645446924cf1871e3ca8796e8318f72465d2b5af9323a835df93bf0917",
    "input": {
      "prompt": "style of 80s cyberpunk, a portrait photo of a developer wearing headphones in front of a glowing terminal",
      "lora_weights": "fofr/flux-80s-cyberpunk"
    }
  }'

# Step 2: Check prediction status (replace {id} with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-image-fast-fine-tuning-black-forest-labs-flux-dev-lora/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) | none | Image URL | No | Input image for image-to-image mode. The aspect ratio of the output matches this image. |
| prompt_strength | number | 0.8 | 0 to 1 | No | Prompt strength in image-to-image mode. 1.0 fully replaces the information in the input image. |
| num_outputs | integer | 1 | 1 to 4 | No | Number of images to generate. Each image is billed (see Pricing). |
| 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 | 3 | 0 to 10 | No | Guidance for the generated image. |
| seed | integer | none | 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 on, even if you set a seed. |
| lora_weights | string | none | LoRA model ID (`<owner>/<model-name>` or `<owner>/<model-name>/<version>`), huggingface.co/`<owner>`/`<model-name>`[/`<file>.safetensors`], civitai.com/models/`<id>`[/`<model-name>`], or a .safetensors URL (signed URLs work) | No | LoRA weights to load, for example "fofr/flux-80s-cyberpunk". |
| lora_scale | number | 1 | -1 to 3 | No | How strongly the main LoRA is applied. Values between 0 and 1 give sensible results for base inference. With `go_fast`, a 1.5x multiplier is applied to this value, so you may need to experiment. |
| extra_lora | string | none | Same formats as `lora_weights` (HuggingFace URLs as huggingface.co/`<owner>`/`<model-name>`) | No | A second set of LoRA weights to load. |
| extra_lora_scale | number | 1 | -1 to 3 | No | How strongly the extra LoRA is applied. Values between 0 and 1 give sensible results for base inference. With `go_fast`, a 1.5x multiplier is applied to this value. |
| megapixels | string | "1" | "1", "0.25" | No | Approximate number of megapixels for the generated image. |
| hf_api_token | string | none | Your HuggingFace token | No | Your own HuggingFace API token. Only needed when the HuggingFace LoRA you load requires authentication. |
| civitai_api_token | string | none | Your CivitAI token | No | Your own CivitAI API token. Only needed when the CivitAI LoRA you load requires authentication. |

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

- **Where can I load LoRA weights from?**
  From a LoRA model ID such as "fofr/flux-80s-cyberpunk", a HuggingFace URL, a CivitAI URL, or any .safetensors URL, including signed URLs.

- **What are `hf_api_token` and `civitai_api_token` for?**
  Some HuggingFace and CivitAI LoRAs require authentication. If yours does, pass your own token for that site in the matching field. They are not needed for public LoRAs.

- **Why do I get different images with the same seed?**
  With `go_fast` on (the default) outputs are not deterministic, even with a seed. Set `go_fast` to false for repeatable results.

- **How is a request with several images billed?**
  Each output image is 1 unit ($0.04), so `num_outputs` 4 costs $0.16.

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


Text-to-image with FLUX.1 [dev] by Black Forest Labs plus LoRA weights from a model ID, HuggingFace, CivitAI or a .safetensors URL. $0.04 per image.