Name: Text-to-Image API with LoRA (FLUX.1 Schnell LoRA)
Brand: magicapi
SKU: api-magicapi-fast-image-generator-black-forest-labs-flux-schnell-lora
Availability: InStock
Author: API Market

Shashank Agarwal

# 🚀 Fast Text-to-Image API with Custom LoRA Weights (FLUX.1 Schnell LoRA)

## Overview
FLUX.1 [schnell] LoRA, from Black Forest Labs, generates images from a text prompt and can load your own LoRA weights to apply a fine-tuned style, character or subject. It is built for fast generation and for use with fine-tuned weights. Point `lora_weights` at a model ID, a Hugging Face repo, a CivitAI model or any .safetensors URL, and set `lora_scale` to control how strongly it is applied.

## Features
- Text-to-image from a `prompt` (the only required field)
- Load LoRA weights from a model ID (`<owner>/<model-name>`), Hugging Face, CivitAI or a direct .safetensors URL
- `lora_scale` from -1 to 3 (default 1) to control LoRA strength
- 1 to 4 images per request (`num_outputs`)
- 11 aspect ratios, from `21:9` to `9:21` (default `1:1`)
- Output size of about 1 megapixel or 0.25 megapixels (`megapixels`)
- 1 to 4 inference steps (default and recommended: 4)
- `go_fast` mode (on by default) runs an fp8 quantized model for speed; turn it off to run the original bf16 model
- WebP, JPG or PNG output with adjustable quality

## Use Cases
### Branded or consistent styles
Apply a LoRA trained on your brand style, product or character to get on-style images from short prompts.

### Testing community LoRAs
Try LoRAs from Hugging Face or CivitAI by URL without hosting the model yourself.

### Fast drafts and thumbnails
Generate several low step or 0.25 megapixel variations quickly, then pick one to refine.

## Visual Examples
This is the request we ran through api.market, using the `fofr/flux-80s-cyberpunk` LoRA with all other fields at their defaults.

**Prompt:** "style of 80s cyberpunk, a portrait of a developer in front of a glowing terminal"

**LoRA (`lora_weights`):** `fofr/flux-80s-cyberpunk`

**Output:**

![Portrait of a developer in front of a glowing terminal in an 80s cyberpunk style, generated with FLUX.1 schnell and the fofr/flux-80s-cyberpunk LoRA](https://blog.api.market/wp-content/uploads/2026/10/flux-schnell-lora-output-api-market.webp)

## Pricing
- Pay As You Go (PAYG) pricing: you only pay for what you use.
- Price: $0.025 per API unit.
- 1 API unit = 1 output image. A request is billed for every image it returns, so units per request = `num_outputs`.
- `num_outputs: 1` (the default): 1 unit = $0.025.
- `num_outputs: 2`: 2 units = $0.05. `num_outputs: 3`: 3 units = $0.075. `num_outputs: 4`: 4 units = $0.10.
- Aspect ratio, `megapixels`, steps, output format and LoRA settings 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 should be made to: `https://prod.api.market/api/v1/magicapi/fast-image-generator-black-forest-labs-flux-schnell-lora`

### Authentication
Include your api.market API key in the `x-api-market-key` request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API is asynchronous:
1. Send a POST request to `/predictions`. A successful request returns `201 Created` with a prediction `id` and a `status` of `starting` or `processing`. 201 means the job was accepted; it is not an error.
2. Poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
3. When `status` is `succeeded`, `output` holds the generated images as a list of URLs.

Your code should:
- Wait about 1 second between status checks.
- Stop after a timeout you choose (the examples below use 600 seconds).
- Keep polling while `status` is `starting` or `processing`.
- Read `output` when `status` is `succeeded`.
- Handle `failed` and `canceled` (read the `error` field) and the timeout case.

### Endpoints
#### POST /predictions
Create a prediction. This is the request we ran for the example above.

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

Response (`201 Created`):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "83180e3ae073b7f87cd85b8bb649337412fd006d10db49e04ea5e821e87fbeb3",
  "status": "starting",
  "created_at": "2026-10-13T11:11:59.334Z"
}
```

#### GET /predictions/{id}
Get the status and result of a prediction.

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-image-generator-black-forest-labs-flux-schnell-lora/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (`200 OK`):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/10/flux-schnell-lora-output-api-market.webp"
  ],
  "created_at": "2026-10-13T11:11:59.334Z",
  "started_at": "2026-10-13T11:12:01.000Z",
  "completed_at": "2026-10-13T11:13:00.000Z"
}
```

### Status Codes
- 200 OK: Status request successful
- 201 Created: Prediction created (success)
- 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
- 503 Service Unavailable: Service temporarily unavailable

### Input Parameters
Send these fields inside `input`. Only `prompt` is required.

| Parameter | Type | Default | Allowed values | Required | Description |
|---|---|---|---|---|---|
| `prompt` | string | none | any | Yes | Prompt for 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. |
| `num_outputs` | integer | `1` | 1 to 4 | No | Number of outputs to generate. |
| `num_inference_steps` | integer | `4` | 1 to 4 | No | Number of denoising steps. 4 is recommended, and lower number of steps produce lower quality outputs, faster. |
| `seed` | integer | none | any | 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, from 0 to 100. 100 is best quality, 0 is lowest quality. Not relevant for .png outputs. |
| `disable_safety_checker` | boolean | `false` | `true`, `false` | No | Disable safety checker for generated images. |
| `go_fast` | boolean | `true` | `true`, `false` | No | Run faster predictions with model optimized for speed (currently fp8 quantized); disable to run in original bf16. Note that outputs will not be deterministic when this is enabled, even if you set a seed. |
| `lora_weights` | string | none | any | No | Load LoRA weights. Supports model IDs in the format `<owner>/<model-name>` or `<owner>/<model-name>/<version>`, Hugging Face URLs in the format `huggingface.co/<owner>/<model-name>`, CivitAI URLs in the format `civitai.com/models/<id>[/<model-name>]`, or arbitrary .safetensors URLs from the Internet. For example, `fofr/flux-pixar-cars`. |
| `lora_scale` | number | `1` | -1 to 3 | No | How strongly the main LoRA is applied. Sane results between 0 and 1 for base inference. When `go_fast` is enabled, a 1.5x multiplier is applied to this value. You may need to experiment to find the best value for your LoRA. |
| `megapixels` | string | `"1"` | `1`, `0.25` | No | Approximate number of megapixels for generated image. |

### 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
### Example Code
#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-image-generator-black-forest-labs-flux-schnell-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: "83180e3ae073b7f87cd85b8bb649337412fd006d10db49e04ea5e821e87fbeb3", 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);
}

function delay(ms) {
  return 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 of a developer in front of a glowing terminal",
  "lora_weights": "fofr/flux-80s-cyberpunk"
}).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-image-generator-black-forest-labs-flux-schnell-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": "83180e3ae073b7f87cd85b8bb649337412fd006d10db49e04ea5e821e87fbeb3", "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")

print(create_and_wait_for_prediction({
    "prompt": "style of 80s cyberpunk, a portrait of a developer in front of a glowing terminal",
    "lora_weights": "fofr/flux-80s-cyberpunk"
}))
```

#### 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-generator-black-forest-labs-flux-schnell-lora/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
  "version": "83180e3ae073b7f87cd85b8bb649337412fd006d10db49e04ea5e821e87fbeb3",
  "input": {
    "prompt": "style of 80s cyberpunk, a portrait of a developer in front of a glowing terminal",
    "lora_weights": "fofr/flux-80s-cyberpunk"
  }
}'

# Step 2: check the prediction status (replace PREDICTION_ID with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-image-generator-black-forest-labs-flux-schnell-lora/predictions/PREDICTION_ID" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Repeat step 2 until status is "succeeded", "failed" or "canceled"
```

### Performance Optimization
- Use `num_outputs` to get up to 4 variations in one request. Each image is billed, but you only poll once.
- Leave `go_fast` on for speed. Turn it off if you need repeatable results from a fixed `seed`, since outputs are not deterministic with `go_fast` enabled.
- Use `megapixels: "0.25"` or fewer steps for quick drafts. Lower step counts are faster but lower quality.
- Poll about once per second and stop polling as soon as the status is final.

## FAQ
**Do I have to use a LoRA?**
No. `lora_weights` is optional. Without it the model generates from the prompt alone.

**Where can my LoRA come from?**
A model ID such as `fofr/flux-80s-cyberpunk`, a Hugging Face URL (`huggingface.co/<owner>/<model-name>`), a CivitAI URL (`civitai.com/models/<id>`), or any public .safetensors URL.

**Why do I get different images with the same seed?**
`go_fast` is on by default, and outputs are not deterministic when it is enabled, even with a seed. Set `go_fast: false` for reproducible results.

**How is a request billed?**
$0.025 per output image. A request with `num_outputs: 4` returns 4 images and costs $0.10. 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 images from a text prompt with FLUX.1 [schnell] from Black Forest Labs, loading your own LoRA weights. Up to 4 images per request, $0.025 per image.