> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laozhang.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Meta Muse Video API: Pricing and Integration

> Call Meta's Muse video model via /v1/videos: text-to-video, first and last frames, reference images, and continuation, with sound and a fixed price per clip.

Muse is Meta's video generation model, and every clip comes with its own music and sound effects. LaoZhang API charges a fixed price per video, \$0.30 for a 5–10 second clip, and any standard token group can call it.

| Item | Details |
| - | - |
| Model IDs | `muse-video` (5, 8, or 10 s), `muse-video-20s`, `muse-video-30s` |
| Create a task | `POST /v1/videos`, JSON or multipart |
| Get a task | `GET /v1/videos/{id}`; read `video_url` when it completes |
| Download | Use `video_url` directly, or `GET /v1/videos/{id}/content` |
| Token groups | `default`, `vip`, or `svip`, with the Usage first billing mode |
| Price | \$0.30, \$0.55, or \$0.80 per video; see [Pricing](#pricing) |
| Output | 24 fps with a soundtrack; 1280×720 at 16:9, other sizes under [Request fields](#request-fields) |
| Retention | Video links stay available for 7 days |
| Route | Meta's official API has no video generation model yet; this route is integrated independently and priced on its own |

![Muse text-to-video sample: a lighthouse on a rocky coast at dawn with waves breaking on the rocks](https://mintcdn.com/laozhangai-edd05f2c/HNpi8TQdPfniogkz/images/samples/muse-video-en-t2v.jpg?fit=max\&auto=format\&n=HNpi8TQdPfniogkz\&q=85\&s=cbb313bc8cdeb5db903cd14e366f2d43)

Output of the text-to-video example below: muse-video, 10 seconds, 16:9

## Create a token

Add a token in [Token management](https://api.laozhang.ai/token) with these settings:

| Setting | Choice |
| - | - |
| Group | `default`, `vip`, or `svip`; all three have the same price |
| Billing mode | Usage first (recommended) or Per-call; a Usage-based-only token cannot call it |
| Tip | Use a separate token for video so you can match charges to tasks in the usage log |

You do not need a Meta account or a dedicated video group.

## Pricing

Muse videos are billed per video. The price does not depend on the duration you pick within a model, the aspect ratio, or whether you send images:

| Model | Clip length | Per video |
| - | - | -: |
| `muse-video` | 5, 8, or 10 s | \$0.30 |
| `muse-video-20s` | 20 s; adds 10 s when continuing a video | \$0.55 |
| `muse-video-30s` | 30 s; adds 20 s when continuing a video | \$0.80 |

How charges work:

* You are charged when the task is created, and failed tasks are refunded in full.
* Requests rejected at submission with a parameter error are not charged.
* Each resubmission creates a new task and is charged again, so keep a mapping between your own job ID and the task `id`.

The [usage log](https://api.laozhang.ai/log) shows the actual charge for every task.

## Choose between video models

As of October 30, 2026, Muse has the lowest price on LaoZhang API for a 10-second clip at 720p or higher; see [Models and pricing](https://docs.laozhang.ai/en/models.md) for every model. Pick by task:

* **Muse**: a fixed price per video, one continuous 20- or 30-second clip, or continuing an existing video.
* **[MiniMax H3](https://docs.laozhang.ai/en/api-capabilities/minimax-h3-video-generation.md)**: 2K output, reference video, or reference audio. For short 768P clips of about 5 seconds, H3's per-second price is lower.
* **[Seedance 2.0](https://docs.laozhang.ai/en/api-capabilities/seedance2-video-generation.md)**: 1080p, or footage of real people or virtual humans.
* **[Wan](https://docs.laozhang.ai/en/api-capabilities/wan-video-generation.md)**: 1080P output, or editing an existing video.

## How it works

**1. Create a task**

Call `POST /v1/videos` with at least `model` and `prompt`. The endpoint is asynchronous: it returns a task `id` within seconds instead of waiting for the video. Save it.

**2. Poll the status**

Call `GET /v1/videos/{id}` every 15 seconds and read `status`; each call returns right away. Clips up to 10 seconds usually finish in 2–3 minutes and can take more than 5 at busy times; 20- and 30-second clips take longer.

**3. Download the result**

When `status` is `completed`, download the MP4 from `video_url`. The download needs no `Authorization` header, and the link stays valid for 7 days.

> [!WARNING]
>
> **Keep polling for up to 30 minutes, and do not resubmit while the task is still running.**
>
> * Submitting and polling both return immediately, so you do not need a longer HTTP timeout.
> * 30 minutes is the polling limit: keep checking while `status` is `queued` or `in_progress`.
> * If you stop polling, check the same `id` again later. Resubmitting creates a new task and charges again.
> * A task still unfinished after 40 minutes is marked failed and refunded in full.

## Set up

The cURL examples use `jq` to read fields from responses (`brew install jq` on macOS). Set your key and base URL first:

```bash theme={null}
export LAOZHANG_API_KEY="your LaoZhang API key"
export BASE_URL="https://api.laozhang.ai"
```

## Generate a video from text

```bash theme={null}
curl -s -X POST "$BASE_URL/v1/videos" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  --data-raw '{
    "model": "muse-video",
    "prompt": "A lighthouse on a rocky coast at dawn, waves crashing on the rocks, a few seagulls flying past, slow push-in, cinematic lighting",
    "seconds": "10",
    "aspect_ratio": "16:9"
  }' | tee muse-create.json

export VIDEO_ID=$(jq -r '.id' muse-create.json)
```

A successful request returns a queued task:

```json theme={null}
{
  "id": "task_qyP7fa67hjtpArfMjnAnOwpVe1UEgyHh",
  "object": "video",
  "model": "muse-video",
  "status": "queued",
  "progress": 0,
  "seconds": "10",
  "created_at": 1793328222
}
```

Two optional fields you will use most:

* `seconds`: leave it out and `muse-video` makes a 10-second clip.
* `aspect_ratio`: the shape of the clip; you can send `size` in pixels instead, such as `720x1280`.

## Animate from a first frame or first and last frames

Pass `image` to set the opening shot, and add `last_frame` to set the closing shot as well. Each image can be a public URL or a `data:image/...;base64,` data URL:

```bash theme={null}
curl -s -X POST "$BASE_URL/v1/videos" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  --data-raw '{
    "model": "muse-video",
    "prompt": "The snow melts and the leaves turn gold as winter changes into autumn",
    "seconds": "8",
    "image": "https://example.com/winter.jpg",
    "last_frame": "https://example.com/autumn.jpg"
  }'
```

The model uses the two images as visual references: the clip opens and closes on the same composition, but details are not reproduced pixel for pixel.

To upload local files, send multipart form data. The first frame goes in `input_reference` and the last frame in `last_frame`:

```bash theme={null}
curl -s -X POST "$BASE_URL/v1/videos" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -F model=muse-video \
  -F prompt="The kitten blinks and yawns" \
  -F seconds=5 \
  -F aspect_ratio=9:16 \
  -F input_reference=@./cat.jpg
```

Do not set `Content-Type: application/json` when you upload with `-F`. Each image can be up to 10 MB.

## Generate from reference images

Send 1–4 images in `reference_images`. The model carries their subject and style into the video without using any of them as the first frame:

```bash theme={null}
curl -s -X POST "$BASE_URL/v1/videos" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  --data-raw '{
    "model": "muse-video",
    "prompt": "This fox walks through a forest that changes from winter to autumn",
    "seconds": "10",
    "aspect_ratio": "16:9",
    "reference_images": [
      "https://example.com/fox-winter.jpg",
      "https://example.com/fox-autumn.jpg"
    ]
  }'
```

## Make 20s and 30s clips or continue a video

`muse-video-20s` and `muse-video-30s` generate one continuous 20- or 30-second clip. Call them the same way as `muse-video`; `seconds` can be left out.

To keep going from an existing clip, pass `video_url`:

```bash theme={null}
curl -s -X POST "$BASE_URL/v1/videos" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  --data-raw '{
    "model": "muse-video-20s",
    "prompt": "The boat drifts into the morning mist as the sun rises over the sea",
    "video_url": "https://example.com/boat-5s.mp4"
  }'
```

Continuation rules:

* Only `muse-video-20s` and `muse-video-30s` accept `video_url`; they add 10 and 20 seconds after the source clip.
* The source must be a publicly downloadable https MP4 link, no longer than 10 seconds.
* The result includes the source clip, so a 5-second source continued with `muse-video-20s` becomes a 15-second video.
* A `video_url` returned by LaoZhang API works as a source.

## Poll and download

### Get the task

```bash theme={null}
curl -s "$BASE_URL/v1/videos/$VIDEO_ID" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY"
```

While the video renders, `status` is `in_progress` and `progress` gives a rough percentage:

```json theme={null}
{
  "id": "task_1OuWjS9JUWpjiin8zr3S3vzhQNjTILIF",
  "object": "video",
  "model": "muse-video",
  "status": "in_progress",
  "progress": 30,
  "seconds": "10",
  "size": "1280x720",
  "created_at": 1793328220
}
```

When it completes, the task carries `video_url`:

```json theme={null}
{
  "id": "task_Qb8zDoLJMSDsOKdRWLMCwzRgkg2EanF0",
  "object": "video",
  "model": "muse-video",
  "status": "completed",
  "progress": 100,
  "seconds": "5",
  "size": "1280x720",
  "created_at": 1793325393,
  "completed_at": 1793325521,
  "video_url": "https://media.laozhang.ai/videos/video_6efb7e6d2b37665752192eb1-a95d03b30c0f.mp4"
}
```

A failed task has `status: "failed"` and the reason in `error.message`. Its charge has already been refunded:

```json theme={null}
{
  "id": "task_GcyZA3g7We2nQOl3QaSQX1nroSKli3O7",
  "object": "video",
  "model": "muse-video",
  "status": "failed",
  "progress": 100,
  "seconds": "8",
  "size": "1280x720",
  "created_at": 1793326360,
  "error": {
    "code": "video_generation_failed",
    "message": "Could not download last_frame (HTTP 429). Use a public image link or a data URL."
  }
}
```

### Download the video

```bash theme={null}
curl -L -o muse-video.mp4 "$(curl -s "$BASE_URL/v1/videos/$VIDEO_ID" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" | jq -r '.video_url')"
```

You can also call `GET /v1/videos/{id}/content` with your `Authorization` header; it returns the MP4 file.

## Minimal Python client

Requires `requests` (`pip install requests`):

```python theme={null}
import os
import time

import requests

BASE_URL = "https://api.laozhang.ai"
HEADERS = {"Authorization": f"Bearer {os.environ['LAOZHANG_API_KEY']}"}

task = requests.post(
    f"{BASE_URL}/v1/videos",
    headers=HEADERS,
    json={
        "model": "muse-video",
        "prompt": "A lighthouse on a rocky coast at dawn, waves crashing on the rocks, a few seagulls flying past, slow push-in, cinematic lighting",
        "seconds": "10",
        "aspect_ratio": "16:9",
    },
    timeout=120,
)
task.raise_for_status()
video_id = task.json()["id"]

deadline = time.time() + 30 * 60
while True:
    video = requests.get(f"{BASE_URL}/v1/videos/{video_id}", headers=HEADERS, timeout=60).json()
    if video["status"] == "completed":
        break
    if video["status"] == "failed":
        raise RuntimeError(video["error"]["message"])
    if time.time() > deadline:
        raise TimeoutError(f"{video_id} is still running; keep polling the same id later")
    time.sleep(15)

with open("muse-video.mp4", "wb") as f:
    f.write(requests.get(video["video_url"], timeout=300).content)
print("Saved muse-video.mp4,", video["seconds"], "seconds")
```

## API reference

### Request fields

| Field | Required | Description |
| - | - | - |
| `model` | Yes | `muse-video`, `muse-video-20s`, or `muse-video-30s` |
| `prompt` | Yes | What happens on screen and what it sounds like |
| `seconds` | No | `5`, `8`, or `10` for `muse-video` (default 10); 20 or 30 for the longer models, or leave it out |
| `aspect_ratio` | No | `16:9`, `9:16`, `1:1`, `4:3`, or `3:4` |
| `size` | No | The shape in pixels, such as `1280x720` or any output size in the table below; use instead of `aspect_ratio` |
| `image` | No | First frame; the multipart field name is `input_reference` |
| `last_frame` | No | Last frame |
| `reference_images` | No | Array of up to 4 reference images |
| `video_url` | No | Source clip to continue; 20s and 30s models only |
| `negative_prompt` | No | Things to keep out of the video |
| `style`, `camera_motion` | No | Style and camera hints such as `cinematic` or `zoom_in`, used as guidance |

Output size by aspect ratio:

| `aspect_ratio` | Output size |
| - | - |
| `16:9` | 1280×720 |
| `9:16` | 720×1280 |
| `1:1` | 960×960 |
| `4:3` | 1088×816 |
| `3:4` | 816×1088 |

The frame rate is always 24 fps; `resolution` and `fps` do not change the output.

### Task status

| `status` | Meaning | Next step |
| - | - | - |
| `queued` | Created, waiting to render | Keep polling |
| `in_progress` | Rendering | Keep polling |
| `completed` | Done | Download from `video_url` |
| `failed` | Failed and refunded | Fix the request according to `error.message` and create a new task |

## Errors

| Error | Cause | Fix |
| - | - | - |
| `seconds must be 5, 8, 10 for muse-video.` | The duration is not one this model offers | Use 5, 8, or 10, or switch to the 20s or 30s model |
| `video_url (continue a video) needs muse-video-20s or muse-video-30s.` | Continuation was sent to `muse-video` | Use `muse-video-20s` or `muse-video-30s` |
| `Send at most 4 reference_images.` | More than 4 reference images | Send 4 or fewer |
| `Could not download image (HTTP 403)…` | The image link needs a login, blocks downloads, or is rate-limited | Use a link anyone can download, or send a data URL |
| `image must be a public internet link.` | The image link points to a private, local, or unresolvable address | Use a link anyone can download, or send a data URL |
| `video_url can be at most 10 seconds long…` | The source clip is longer than 10 seconds | Trim it to 10 seconds or less first |
| `The model returned no video for this input…` | The model did not produce a video for this input | Adjust the prompt or use a different image, then create a new task |

The first three come back as HTTP 400 at submission: no task is created and nothing is charged. The rest arrive as a failed task, already refunded.

## FAQ

### Do 5-second and 10-second clips cost the same?

Yes. `muse-video` costs \$0.30 for 5, 8, or 10 seconds. For a longer continuous shot, use `muse-video-20s` (\$0.55) or `muse-video-30s` (\$0.80).

### Can I get 1080p video?

No. Muse outputs 1280×720 in landscape and 720×1280 in portrait; other shapes are listed under [Request fields](#request-fields). Sending `resolution: "1080p"` is accepted, but the output size does not change.

### Do the videos have sound? Can I turn it off?

Every clip has a soundtrack, with music and effects shaped by your prompt. There is no option to turn it off; strip the audio track after downloading if you do not need it.

### Can I resubmit after a timeout or failure?

Check the task first. A client-side timeout does not mean the task failed, so keep polling the same `id`; resubmitting creates a new task and charges again. Only when `status` is `failed` should you fix the request and create a new task. Failed tasks are already refunded, and a task still unfinished after 40 minutes is marked failed and refunded automatically.

### How long are video links kept?

7 days. After that the link expires and the task cannot be downloaded again, so save the file once the task completes.

## Related docs

* [MiniMax H3 video API](https://docs.laozhang.ai/en/api-capabilities/minimax-h3-video-generation.md)
* [Seedance 2.0 video API](https://docs.laozhang.ai/en/api-capabilities/seedance2-video-generation.md)
* [Wan 2.7 and Wan 3.0 video API](https://docs.laozhang.ai/en/api-capabilities/wan-video-generation.md)
* [Models and pricing](https://docs.laozhang.ai/en/models.md)
* [Usage logs](https://docs.laozhang.ai/en/faq/call-logs.md)
* [Meta Model API models](https://dev.meta.ai/resources/blog/build-with-muse-spark): Muse Spark, Muse Image, and others, with no video generation model (checked October 30, 2026)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.