Name: Leonardo Motion 2.0 Text-to-Video API
Brand: magicapi
SKU: api-magicapi-text-to-video-creator-leonardoai-motion-2-0
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Text-to-Video API - Short 480p Clips with Style Presets (Leonardo Motion 2.0)

## Overview
Motion 2.0 is a video generation model from Leonardo.Ai. Its developer describes it as creating 5 second 480p videos from a text prompt.

Send a text `prompt` to generate a video. Add an optional `image` to use as the first frame of the video. Style presets for vibe, lighting, shot type and color theme let you steer the look without writing it into the prompt. Each request returns the URL of one video.

## Features
- **Text to video**: describe the scene in `prompt`.
- **First frame image**: pass `image` to start the video from your picture. When `image` is set, `aspect_ratio` and the four style presets are ignored.
- **Aspect ratios**: `16:9` (default), `9:16`, `2:3`, `4:5`.
- **Vibe presets** (`vibe_style`): `clay`, `color_sketch`, `logo`, `papercraft`, `pro_photo`, `sci_fi`, `sketch`, `stock_footage`, `streetshot`.
- **Lighting presets** (`lighting_style`): `backlight`, `candle_lit`, `chiaroscuro`, `film_haze`, `foggy`, `golden_hour`, `hardlight`, `lens_flare`, `light_art`, `low_key`, `luminous`, `mystical`, `rainy`, `soft_light`, `volumetric`.
- **Shot type presets** (`shot_type_style`): `bokeh`, `cinematic`, `close_up`, `overhead`, `spiritual`, `spooky`.
- **Color theme presets** (`color_theme_style`): `autumn`, `complimentary`, `cool`, `dark`, `earthy`, `electric`, `iridescent`, `pastel`, `split`, `terracotta_teal`, `ultraviolet`, `vibrant`, `warm`.
- **Prompt enhancement**: `prompt_enhance` (default `true`) rewrites your prompt before generation. Set it to `false` to use your prompt as written.
- **Frame interpolation**: `frame_interpolation` (default `true`) blends frames for smoother motion.
- **Negative prompt**: describe what to avoid with `negative_prompt`.

## Use Cases
1. **Short social clips**: vertical (`9:16`, `4:5`, `2:3`) or widescreen (`16:9`) videos for posts and stories.
2. **Mood shots for marketing**: combine lighting, shot type and color theme presets to get a consistent look across clips.
3. **Animating a still image**: use a product shot or illustration as `image` and describe the motion in `prompt`.
4. **Storyboards and previews**: quickly check how a scene might look before producing it.

## Visual Examples
### Example Input
Prompt: "A paper sailboat drifts across a calm lake at dawn while mist rises from the water and birds glide overhead."

Aspect ratio: `16:9`. Lighting style: `golden_hour`. Shot type style: `cinematic`. All other fields were left at their defaults (no first frame image, no vibe or color theme preset).

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

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for generation |
| `image` | string (URL) | No | none |  | Image to use for the first frame of the video |
| `aspect_ratio` | string | No | `16:9` | `9:16`, `16:9`, `2:3`, `4:5` | Aspect ratio of the output video. Ignored if image is provided. |
| `negative_prompt` | string | No | none |  | The negative prompt used for the video generation |
| `prompt_enhance` | boolean | No | `true` |  | Whether to enhance the prompt |
| `frame_interpolation` | boolean | No | `true` |  | Smoothly blend frames for fluid video transitions |
| `vibe_style` | string | No | `None` | `None`, `clay`, `color_sketch`, `logo`, `papercraft`, `pro_photo`, `sci_fi`, `sketch`, `stock_footage`, `streetshot` | Style for the overall vibe of the video. Ignored if image is provided. |
| `lighting_style` | string | No | `None` | `None`, `backlight`, `candle_lit`, `chiaroscuro`, `film_haze`, `foggy`, `golden_hour`, `hardlight`, `lens_flare`, `light_art`, `low_key`, `luminous`, `mystical`, `rainy`, `soft_light`, `volumetric` | Style for the lighting of the video. Ignored if image is provided. |
| `shot_type_style` | string | No | `None` | `None`, `bokeh`, `cinematic`, `close_up`, `overhead`, `spiritual`, `spooky` | Style for the shot type of the video. Ignored if image is provided. |
| `color_theme_style` | string | No | `None` | `None`, `autumn`, `complimentary`, `cool`, `dark`, `earthy`, `electric`, `iridescent`, `pastel`, `split`, `terracotta_teal`, `ultraviolet`, `vibrant`, `warm` | Style for the color theme of the video. Ignored if image is provided. |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.375 per API unit.
- **1 API unit = 1 output video.** Each request returns one video, so each successful request costs $0.375.
- Every input setting (aspect ratio, style presets, first frame image) is billed the same. The example request above cost $0.375.
- **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/text-to-video-creator-leonardoai-motion-2-0`

### 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/text-to-video-creator-leonardoai-motion-2-0/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "0cd08fd133f6bfffec01dcb8e21488169f8ce9676dd825a45e99b7c5476d7b40",
    "input": {
      "prompt": "A paper sailboat drifts across a calm lake at dawn while mist rises from the water and birds glide overhead.",
      "aspect_ratio": "16:9",
      "lighting_style": "golden_hour",
      "shot_type_style": "cinematic"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "mvvfk0991srmy0d17frtga0s7m",
  "version": "0cd08fd133f6bfffec01dcb8e21488169f8ce9676dd825a45e99b7c5476d7b40",
  "status": "starting",
  "created_at": "2026-10-14T19:43:42.982Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-creator-leonardoai-motion-2-0/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "mvvfk0991srmy0d17frtga0s7m",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/motion-2-0-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-14T19:43:42.982Z",
  "started_at": "2026-10-14T19:43:43.982Z",
  "completed_at": "2026-10-14T19:44:31.982Z"
}
```

`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 an `aspect_ratio` that is not in the list.
- **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/text-to-video-creator-leonardoai-motion-2-0";

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: "0cd08fd133f6bfffec01dcb8e21488169f8ce9676dd825a45e99b7c5476d7b40", 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 paper sailboat drifts across a calm lake at dawn while mist rises from the water and birds glide overhead.",
  aspect_ratio: "16:9",
  lighting_style: "golden_hour",
  shot_type_style: "cinematic"
}).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/text-to-video-creator-leonardoai-motion-2-0"

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": "0cd08fd133f6bfffec01dcb8e21488169f8ce9676dd825a45e99b7c5476d7b40", "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 paper sailboat drifts across a calm lake at dawn while mist rises from the water and birds glide overhead.",
    "aspect_ratio": "16:9",
    "lighting_style": "golden_hour",
    "shot_type_style": "cinematic",
}))
```

## FAQ
- **Can I start the video from my own image?**
  - Yes. Pass the image URL as `image`. It becomes the first frame. In that case `aspect_ratio`, `vibe_style`, `lighting_style`, `shot_type_style` and `color_theme_style` are ignored.
- **Can I combine several style presets?**
  - Yes. `vibe_style`, `lighting_style`, `shot_type_style` and `color_theme_style` are separate fields, so you can set any of them together. Leave a field at `None` to skip it.
- **Why does my video differ from my exact prompt?**
  - `prompt_enhance` is `true` by default and rewrites the prompt before generation. Set it to `false` to turn this off.
- **How much does one video cost?**
  - $0.375. Each request returns one video, billed as one API unit, whatever presets or aspect ratio 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`.

## 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 short 480p videos from text or a first frame image with Leonardo Motion 2.0, steered by lighting, shot type, vibe and color presets. $0.375 per video.