Name: Wan 2.1 LoRA API: Text and Image to Video with LoRA
Brand: magicapi
SKU: api-magicapi-text-to-video-lora-wan-video-wan2-1-with-lora
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎞️ Text-to-Video Generator with LoRA API (Alibaba Wan 2.1)

## Overview
This API runs Wan 2.1, the open video generation model from Alibaba, in its 14B or 1.3B size with an optional LoRA. You describe a scene in `prompt`, optionally pass a starting `image` for image-to-video, and point `lora_url` at a LoRA file to apply a trained style or subject.

Each request returns a list with the URL of one MP4 video of 17 to 81 frames (1 to 5 seconds).

## Features
- **Text-to-video and image-to-video**: generate from a prompt alone, or start from an `image`.
- **Bring your own LoRA**: pass the URL of a LoRA file in `lora_url` and set `lora_strength_model` and `lora_strength_clip`. A LoRA works with either the 1.3B or the 14B model, depending on which one it was trained on.
- **Two model sizes**: `14b` (default, better quality) or `1.3b` (faster).
- **Resolution and shape**: `480p` (default) or `720p` (14B only), in `16:9` (default), `9:16` or `1:1`.
- **Length**: `frames` of 17, 33, 49, 65 or 81 (default), from 1 to 5 seconds.
- **Speed modes**: `fast_mode` `Off`, `Balanced` (default) or `Fast`. Faster modes may reduce quality somewhat.
- **Sampling controls**: `sample_steps` (1 to 60, default 30), `sample_guide_scale` (0 to 10, default 5), `sample_shift` (0 to 10, default 8), `negative_prompt` and `seed`.

## Use Cases
1. **Styled animation clips**: short clips in the look of a style LoRA, such as flat-color 2D animation.
2. **Character and brand consistency**: apply a LoRA trained on a character or product to keep it consistent across clips.
3. **Animating a still**: bring a starting image to life with image-to-video.
4. **Social and ad content**: vertical `9:16` or square `1:1` clips for feeds.

## Visual Examples
### Example Input
Prompt: "flat color 2d animation of a portrait of woman with white hair and green eyes, dynamic scene"

Settings: `model` `14b`, `frames` 81, `aspect_ratio` `16:9`, `lora_url` set to a flat-color style LoRA (`wan_flat_color_v2.safetensors`), `lora_strength_model` 1, `lora_strength_clip` 1, `sample_steps` 30, `sample_guide_scale` 5, `sample_shift` 8.

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/wan2-1-with-lora-output-xy66npfx-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for video generation |
| `negative_prompt` | string | No | `""` |  | Things you do not want to see in your video |
| `image` | string (URL) | No | none |  | Image to use as the starting frame for image-to-video generation |
| `aspect_ratio` | string | No | `16:9` | `16:9`, `9:16`, `1:1` | Aspect ratio of the video |
| `frames` | integer | No | `81` | `17`, `33`, `49`, `65`, `81` | Number of frames to generate (1 to 5 seconds) |
| `model` | string | No | `14b` | `1.3b`, `14b` | Model to use. 1.3b is faster, 14b is better quality. A LoRA works with either 1.3b or 14b, depending on the version it was trained on. |
| `resolution` | string | No | `480p` | `480p`, `720p` | Resolution of the video. 720p is not supported for 1.3b. |
| `lora_url` | string | No | none |  | Optional URL of a LoRA to use |
| `lora_strength_model` | number | No | `1` |  | Strength of the LoRA applied to the model. 0.0 is no LoRA. |
| `lora_strength_clip` | number | No | `1` |  | Strength of the LoRA applied to the CLIP model. 0.0 is no LoRA. |
| `fast_mode` | string | No | `Balanced` | `Off`, `Balanced`, `Fast` | Speed up generation with different levels of acceleration. Faster modes may degrade quality somewhat; the speedup depends on the content. |
| `sample_steps` | integer | No | `30` | 1 to 60 | Number of generation steps. Fewer steps are faster but lower quality; 30 steps is enough for most prompts. |
| `sample_guide_scale` | number | No | `5` | 0 to 10 | Higher values improve prompt adherence but can reduce variation |
| `sample_shift` | number | No | `8` | 0 to 10 | Sample shift factor |
| `seed` | integer | No | random |  | Set a seed for reproducibility |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $1.84 per API unit.
- **1 API unit = one request with up to 1,085 seconds of processing.** A request that takes longer is billed one more unit for every started 1,085-second block (for example, 1,085 to 2,170 seconds is 2 units, $3.68).
- The 14B model, `720p`, more `frames` or more `sample_steps` take longer than the 1.3B model, `480p`, fewer frames or fewer steps.
- **Example cost**: the example request took 319.9 seconds of processing, so it used 1 unit ($1.84).
- **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-lora-wan-video-wan2-1-with-lora`

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

Video generation takes several minutes. A polling interval of 5 seconds and an overall timeout of 1,800 seconds (30 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-lora-wan-video-wan2-1-with-lora/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c48fa8ec65b13143cb552ab98ea17984eab9d70e9fe99479117de40a2a7f9ed0",
    "input": {
      "model": "14b",
      "frames": 81,
      "prompt": "flat color 2d animation of a portrait of woman with white hair and green eyes, dynamic scene",
      "lora_url": "https://huggingface.co/motimalu/wan-flat-color-v2/resolve/main/wan_flat_color_v2.safetensors",
      "aspect_ratio": "16:9",
      "sample_shift": 8,
      "sample_steps": 30,
      "lora_strength_clip": 1,
      "sample_guide_scale": 5,
      "lora_strength_model": 1
    }
  }'
```

Response (201 Created):
```json
{
  "id": "xy66npfxtxrn80d1d8xa5d7gdc",
  "version": "c48fa8ec65b13143cb552ab98ea17984eab9d70e9fe99479117de40a2a7f9ed0",
  "status": "starting",
  "created_at": "2026-10-23T19:26:53.602Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-lora-wan-video-wan2-1-with-lora/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "xy66npfxtxrn80d1d8xa5d7gdc",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/10/wan2-1-with-lora-output-xy66npfx-api-market.mp4"
  ],
  "error": null,
  "created_at": "2026-10-23T19:26:53.602Z",
  "started_at": "2026-10-23T19:26:54.602Z",
  "completed_at": "2026-10-23T19:33:30.602Z"
}
```

`output` is a list with the URL of 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 `frames` value 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-lora-wan-video-wan2-1-with-lora";

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: "c48fa8ec65b13143cb552ab98ea17984eab9d70e9fe99479117de40a2a7f9ed0", 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 = 1800000;
  const pollInterval = 5000;
  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 30 minutes");
}

createAndWaitForPrediction({
  model: "14b",
  frames: 81,
  prompt: "flat color 2d animation of a portrait of woman with white hair and green eyes, dynamic scene",
  lora_url: "https://huggingface.co/motimalu/wan-flat-color-v2/resolve/main/wan_flat_color_v2.safetensors",
  aspect_ratio: "16:9",
  sample_shift: 8,
  sample_steps: 30,
  lora_strength_clip: 1,
  sample_guide_scale: 5,
  lora_strength_model: 1
}).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-lora-wan-video-wan2-1-with-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": "c48fa8ec65b13143cb552ab98ea17984eab9d70e9fe99479117de40a2a7f9ed0", "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 = 1800
    poll_interval = 5
    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 30 minutes")


print(create_and_wait_for_prediction({
    "model": "14b",
    "frames": 81,
    "prompt": "flat color 2d animation of a portrait of woman with white hair and green eyes, dynamic scene",
    "lora_url": "https://huggingface.co/motimalu/wan-flat-color-v2/resolve/main/wan_flat_color_v2.safetensors",
    "aspect_ratio": "16:9",
    "sample_shift": 8,
    "sample_steps": 30,
    "lora_strength_clip": 1,
    "sample_guide_scale": 5,
    "lora_strength_model": 1
}))
```

## FAQ
- **Which LoRA files can I use?**
  - Any LoRA reachable at a URL in `lora_url`, trained for Wan 2.1. A LoRA works with either the `1.3b` or the `14b` model, depending on which one it was trained on, so set `model` to match.
- **Can I run without a LoRA?**
  - Yes. `lora_url` is optional; leave it out to use the base model.
- **How long are the videos?**
  - Between 1 and 5 seconds, set by `frames` (17, 33, 49, 65 or 81; default 81).
- **Can I get 720p?**
  - Yes, with `resolution` `720p` on the `14b` model. 720p is not supported for `1.3b`.
- **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`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page. You can also email our support team at hello@magicapi.com.


Generate 1 to 5 second videos from a text prompt or a starting image with Wan 2.1 14B or 1.3B, styled by a LoRA you supply by URL.