Name: Fast Image Generator API (Luma Photon Flash)
Brand: magicapi
SKU: api-magicapi-ultra-fast-image-generator-luma-photon-flash
Availability: InStock
Author: API Market

Shashank Agarwal

# 🚀 Fast Image Generator API (Luma Photon Flash)

## Overview
The **Fast Image Generator API (Luma Photon Flash)** creates images from text with Luma's Photon Flash, a variant of the Photon model that prioritizes speed while keeping quality. Describe the image in a `prompt`, pick an aspect ratio, and optionally pass reference images that guide the content, the style or a character. Each request returns a URL to one generated image.

## Features
- **Text-to-image:** `prompt` is the only required field.
- **Aspect ratios:** `1:1`, `3:4`, `4:3`, `9:16`, `16:9` (default), `9:21` or `21:9`.
- **Image reference:** `image_reference` guides the generation with a reference image; `image_reference_weight` (0 to 1, default 0.85) sets how strongly it influences the result.
- **Style reference:** `style_reference` guides the visual style; `style_reference_weight` (0 to 1, default 0.85) sets its strength.
- **Character reference:** `character_reference` guides the generation with a character reference image.
- **Reproducible results:** set `seed` to repeat a generation.

## Use Cases
### Rapid Concepting
Try many prompt variations quickly while exploring an idea for a campaign, product page or game.

### Social and Blog Images
Generate illustrations and header images in the aspect ratio each channel needs, from square to tall `9:16` or wide `21:9`.

### On-Style Visuals
Pass a `style_reference` image so a set of generated images shares the same look.

### Recurring Characters
Use `character_reference` to keep a character recognizable across several images.

## Visual Examples
This is the real request we sent through api.market and the image it produced.

**Prompt used:**
> A tiny greenhouse on a city rooftop at sunrise, filled with tomato plants, a small chalkboard sign that reads 'api.market garden'

**Settings:** `aspect_ratio` `16:9`, all other fields at their defaults. No reference images were used.

**Output:**

![A small glass greenhouse full of tomato plants on a city rooftop at sunrise, with a chalkboard sign in front](https://blog.api.market/wp-content/uploads/2026/10/photon-flash-output-api-market.jpg)

## Pricing
- **Pay As You Go (PAYG) pricing:** you only pay for what you use.
- **Price:** $0.013 per API unit.
- **1 API unit:** one generated image. Each request returns one image, so every successful request costs $0.013, whatever the aspect ratio or reference images.
- **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
```
https://prod.api.market/api/v1/magicapi/ultra-fast-image-generator-luma-photon-flash
```

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

### Asynchronous Processing
**IMPORTANT:** This API is asynchronous.
1. Send `POST /predictions` with the model `version` and your `input`. A successful call returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. 201 means the prediction was accepted; it is not an error.
2. Poll `GET /predictions/{id}` every second or two.
3. Stop when `status` is `succeeded` (the `output` field holds the image URL), `failed` (see the `error` field) or `canceled`.

### Endpoints

#### POST /predictions
Create a prediction. This is the request used for the example on this page:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-image-generator-luma-photon-flash/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "8cee7d47f81d8f4f77c1aec44ffb3d1ce09d36388db637ceaa8a6cbcf30b63e1",
    "input": {
      "prompt": "A tiny greenhouse on a city rooftop at sunrise, filled with tomato plants, a small chalkboard sign that reads '\''api.market garden'\''",
      "aspect_ratio": "16:9"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "8cee7d47f81d8f4f77c1aec44ffb3d1ce09d36388db637ceaa8a6cbcf30b63e1",
  "status": "starting",
  "created_at": "2026-10-12T10:40:25.757Z"
}
```

#### GET /predictions/{id}
Check the status of a prediction.
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-image-generator-luma-photon-flash/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when finished (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/photon-flash-output-api-market.jpg",
  "error": null,
  "created_at": "2026-10-12T10:40:25.757Z",
  "started_at": "2026-10-12T10:40:25.798Z",
  "completed_at": "2026-10-12T10:40:32.257Z"
}
```

`output` is a single URL to the generated image.

### Input Parameters
| Parameter | Type | Default | Allowed values | Required | Description |
|---|---|---|---|---|---|
| `prompt` | string | none | Any text | Yes | Text prompt for image generation. |
| `aspect_ratio` | string | `16:9` | `1:1`, `3:4`, `4:3`, `9:16`, `16:9`, `9:21`, `21:9` | No | Aspect ratio of the generated image. |
| `seed` | integer | none | Any integer | No | Random seed. Set it for reproducible generation. |
| `image_reference` | string (URI) | none | Image URL | No | Reference image to guide generation. |
| `image_reference_weight` | number | `0.85` | 0 to 1 | No | Weight of the reference image. Larger values give the reference image a stronger influence. |
| `style_reference` | string (URI) | none | Image URL | No | Style reference image to guide generation. |
| `style_reference_weight` | number | `0.85` | 0 to 1 | No | Weight of the style reference image. |
| `character_reference` | string (URI) | none | Image URL | No | Character reference image to guide generation. |
| `image_reference_url` | string | none | Image URL | No | Deprecated. Use `image_reference` instead. |
| `style_reference_url` | string | none | Image URL | No | Deprecated. Use `style_reference` instead. |
| `character_reference_url` | string | none | Image URL | No | Deprecated. Use `character_reference` instead. |

### Status Codes
- **201 Created:** Prediction created (POST). This is the normal success response.
- **200 OK:** Prediction details returned (GET).
- **400 Bad Request:** Invalid input, for example a missing `prompt`, an unsupported `aspect_ratio` or a weight outside 0 to 1.
- **401 Unauthorized:** Missing or invalid API key.
- **404 Not Found:** No prediction with that ID.
- **429 Too Many Requests:** Too many requests in a short time. Wait and retry.
- **500 Internal Server Error:** Server-side error. Retry after a short wait.

### Error Handling
- A 201 response only means the prediction was accepted. Always poll until `status` is `succeeded`, `failed` or `canceled`.
- When `status` is `failed`, read the `error` field, fix the input and send a new request. Failed predictions are not billed.
- For 429 and 5xx responses, retry with exponential backoff.

## 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/ultra-fast-image-generator-luma-photon-flash";
const version = "8cee7d47f81d8f4f77c1aec44ffb3d1ce09d36388db637ceaa8a6cbcf30b63e1";

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

async function generateImage(input) {
  const createResponse = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version, input })
  });
  if (createResponse.status !== 201 && createResponse.status !== 200) {
    throw new Error(`API error: ${createResponse.status} ${await createResponse.text()}`);
  }
  const { id } = await createResponse.json();

  const deadline = Date.now() + 10 * 60 * 1000;
  while (Date.now() < deadline) {
    const pollResponse = await fetch(`${baseUrl}/predictions/${id}`, {
      headers: { "x-api-market-key": apiKey }
    });
    if (!pollResponse.ok) {
      throw new Error(`API error: ${pollResponse.status} ${await pollResponse.text()}`);
    }
    const prediction = await pollResponse.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(1000);
  }
  throw new Error("Prediction timed out after 10 minutes");
}

generateImage({
  "prompt": "A tiny greenhouse on a city rooftop at sunrise, filled with tomato plants, a small chalkboard sign that reads 'api.market garden'",
  "aspect_ratio": "16:9"
}).then((url) => console.log("Image:", url));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ultra-fast-image-generator-luma-photon-flash"
VERSION = "8cee7d47f81d8f4f77c1aec44ffb3d1ce09d36388db637ceaa8a6cbcf30b63e1"

def generate_image(input_data, timeout_seconds=600):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": VERSION, "input": input_data},
    )
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    prediction_id = response.json()["id"]

    deadline = time.time() + timeout_seconds
    while time.time() < deadline:
        poll = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        poll.raise_for_status()
        prediction = poll.json()
        if prediction["status"] == "succeeded":
            return prediction["output"]
        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error')}")
        time.sleep(1)
    raise TimeoutError("Prediction timed out")

url = generate_image({
  "prompt": "A tiny greenhouse on a city rooftop at sunrise, filled with tomato plants, a small chalkboard sign that reads 'api.market garden'",
  "aspect_ratio": "16:9"
})
print("Image:", url)
```

### cURL
```bash
# Step 1: create the prediction (returns 201 with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-image-generator-luma-photon-flash/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "8cee7d47f81d8f4f77c1aec44ffb3d1ce09d36388db637ceaa8a6cbcf30b63e1",
    "input": {
      "prompt": "A tiny greenhouse on a city rooftop at sunrise, filled with tomato plants, a small chalkboard sign that reads '\''api.market garden'\''",
      "aspect_ratio": "16:9"
    }
  }'

# Step 2: poll with the id from step 1 until status is succeeded, failed or canceled
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-image-generator-luma-photon-flash/predictions/PREDICTION_ID" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Tips
- Put the most important subject and setting first in the prompt.
- Lower `image_reference_weight` or `style_reference_weight` if the result copies the reference too closely; raise it for a stronger influence.
- Reuse the same `seed` and prompt to get the same image again while you change one setting at a time.

## FAQ
### How many images does one request return?
One. `output` is a single image URL, and each request is billed as 1 unit ($0.013).

### Can I edit an existing image with this API?
No. Reference images only guide a new generation; the API does not edit the reference image itself.

### Should I use `image_reference` or `image_reference_url`?
Use `image_reference`, `style_reference` and `character_reference`. The `*_url` fields are deprecated.

### What happens if a prediction fails?
It is not billed. Read the `error` field, fix 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.


Luma Photon Flash API: text-to-image generation in 7 aspect ratios with optional image, style and character reference images. $0.013 per image.