Name: Luma Ray Flash 2 540p Video Generation API
Brand: magicapi
SKU: api-magicapi-fast-540p-video-generator-luma-ray-flash-2-540p
Availability: InStock
Author: API Market

Shashank Agarwal

# ⚡ Fast 540p Video Generation API (Luma Ray Flash 2)

## Overview
Ray Flash 2 (540p) is a video generation model from Luma AI. It generates 540p videos of 5 or 9 seconds from a text `prompt`. You can also give it an image to use as the first frame (`start_image`), the last frame (`end_image`), or both. Luma describes it as a faster and cheaper version of Ray 2.

Only `prompt` is required. Each request returns the URL of one video.

## Features
- **Text to video**: describe the scene in `prompt`.
- **First and last frames**: pass `start_image`, `end_image` or both to control how the video starts and ends.
- **Duration**: `5` (default) or `9` seconds.
- **Aspect ratios**: `1:1`, `3:4`, `4:3`, `9:16`, `16:9` (default), `9:21`, `21:9`.
- **Looping**: set `loop` to `true` so the last frame matches the first for continuous playback.
- **Camera concepts**: pass a list of camera concepts in `concepts`, for example `["push_in"]` or `["aerial_drone", "orbit_left"]`. The available concepts are: truck_left, pan_right, pedestal_down, low_angle, pedestal_up, selfie, pan_left, roll_right, zoom_in, over_the_shoulder, orbit_right, orbit_left, static, tiny_planet, high_angle, bolt_cam, dolly_zoom, overhead, zoom_out, handheld, roll_left, pov, aerial_drone, push_in, crane_down, truck_right, tilt_down, elevator_doors, tilt_up, ground_level, pull_out, aerial, crane_up, eye_level.
- `start_image_url` and `end_image_url` are deprecated; use `start_image` and `end_image` instead.

## Use Cases
1. **Short social and marketing clips**: 5 or 9 second videos in vertical (`9:16`), square (`1:1`) or widescreen (`16:9`) formats.
2. **Drafts and previews**: try out scenes and camera moves at 540p before committing to a longer or higher resolution render.
3. **Animating a still image**: use a photo or illustration as `start_image` and describe the motion in the prompt.
4. **Transitions between two images**: set both `start_image` and `end_image` to generate the movement from one to the other.
5. **Looping backgrounds**: set `loop` to `true` for clips that repeat without a visible cut.

## Visual Examples
### Example Input
Prompt: "A cozy mountain cabin in falling snow at dusk, warm light glowing from the windows as smoke curls from the chimney, slow push in."

Duration: 5 seconds. Aspect ratio: `16:9`. Camera concepts: `["push_in"]`. All other fields were left at their defaults (no loop, no images).

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/ray-flash-2-540p-output-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for video generation |
| `duration` | integer | No | `5` | `5`, `9` | Duration of the video in seconds |
| `aspect_ratio` | string | No | `16:9` | `1:1`, `3:4`, `4:3`, `9:16`, `16:9`, `9:21`, `21:9` | Aspect ratio of the generated video |
| `concepts` | array of strings | No | none |  | List of camera concepts to apply to the video generation. Concepts include: truck_left, pan_right, pedestal_down, low_angle, pedestal_up, selfie, pan_left, roll_right, zoom_in, over_the_shoulder, orbit_right, orbit_left, static, tiny_planet, high_angle, bolt_cam, dolly_zoom, overhead, zoom_out, handheld, roll_left, pov, aerial_drone, push_in, crane_down, truck_right, tilt_down, elevator_doors, tilt_up, ground_level, pull_out, aerial, crane_up, eye_level |
| `start_image` | string (URL) | No | none |  | An optional first frame of the video to use as the starting frame. |
| `end_image` | string (URL) | No | none |  | An optional last frame of the video to use as the ending frame. |
| `loop` | boolean | No | `false` |  | Whether the video should loop, with the last frame matching the first frame for smooth, continuous playback. |
| `start_image_url` | string | No | none |  | Deprecated: Use start_image instead |
| `end_image_url` | string | No | none |  | Deprecated: Use end_image instead |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.042 per API unit.
- **1 API unit = 1 second of output video**, rounded up per request. You are billed on the requested `duration`:
  - `duration` 5 (default): 5 units, 5 x $0.042 = **$0.21** per video
  - `duration` 9: 9 units, 9 x $0.042 = **$0.378** per video
- For example, the 5 second video above costs 5 units, which is $0.21. Aspect ratio, looping, camera concepts and start or end images 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-540p-video-generator-luma-ray-flash-2-540p`

### 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 2 seconds 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-540p-video-generator-luma-ray-flash-2-540p/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "ab7a8dbfe56fe6712c7a64f684930372677a31a3470d260f4786928395c1c5cc",
    "input": {
      "prompt": "A cozy mountain cabin in falling snow at dusk, warm light glowing from the windows as smoke curls from the chimney, slow push in.",
      "duration": 5,
      "aspect_ratio": "16:9",
      "concepts": ["push_in"]
    }
  }'
```

Response (201 Created):
```json
{
  "id": "snfcbpjevdrmy0d17frsv3yv3g",
  "version": "ab7a8dbfe56fe6712c7a64f684930372677a31a3470d260f4786928395c1c5cc",
  "status": "starting",
  "created_at": "2026-10-14T19:43:52.661Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-540p-video-generator-luma-ray-flash-2-540p/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "snfcbpjevdrmy0d17frsv3yv3g",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/ray-flash-2-540p-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-14T19:43:52.661Z",
  "started_at": "2026-10-14T19:43:53.661Z",
  "completed_at": "2026-10-14T19:44:28.661Z"
}
```

`output` is a single URL string pointing to the generated MP4 video.

### 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 `duration` other than 5 or 9.
- **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. 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-540p-video-generator-luma-ray-flash-2-540p";

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: "ab7a8dbfe56fe6712c7a64f684930372677a31a3470d260f4786928395c1c5cc", 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 = 2000;
  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 mountain cabin in falling snow at dusk, warm light glowing from the windows as smoke curls from the chimney, slow push in.",
  duration: 5,
  aspect_ratio: "16:9",
  concepts: ["push_in"]
}).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-540p-video-generator-luma-ray-flash-2-540p"

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": "ab7a8dbfe56fe6712c7a64f684930372677a31a3470d260f4786928395c1c5cc", "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 = 2
    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 mountain cabin in falling snow at dusk, warm light glowing from the windows as smoke curls from the chimney, slow push in.",
    "duration": 5,
    "aspect_ratio": "16:9",
    "concepts": ["push_in"],
}))
```

## FAQ
- **How long can the videos be?**
  - 5 or 9 seconds, set with `duration`. The default is 5.
- **How do I control the camera?**
  - Pass one or more camera concepts in `concepts`, for example `["push_in"]` or `["orbit_left", "low_angle"]`. You can also describe the camera move in `prompt`.
- **Can I set both the first and the last frame?**
  - Yes. Pass `start_image` and `end_image` together and describe the motion between them in `prompt`.
- **How much does a video cost?**
  - $0.042 per second of requested duration: $0.21 for a 5 second video and $0.378 for a 9 second video.
- **Should I use `start_image_url` and `end_image_url`?**
  - No. They are deprecated. Use `start_image` and `end_image`.
- **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`.

## 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 Ray Flash 2 API: generate 5 or 9 second 540p videos from text, with optional start and end images, looping and camera concepts. $0.042 per second.