Meta Muse Video API: Pricing and Integration

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
Output	24 fps with a soundtrack; 1280×720 at 16:9, other sizes under 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 — Output of the text-to-video example below: muse-video, 10 seconds, 16:9

Create a token

Add a token in Token management 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 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 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: 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: 1080p, or footage of real people or virtual humans.
Wan: 1080P output, or editing an existing video.

How it works

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.

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.

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.

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:

export LAOZHANG_API_KEY="your LaoZhang API key"
export BASE_URL="https://api.laozhang.ai"

Generate a video from text

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:

{
  "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:

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:

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:

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:

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

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:

{
  "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:

{
  "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:

{
  "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

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):

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. 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.

MiniMax H3 video API
Seedance 2.0 video API
Wan 2.7 and Wan 3.0 video API
Models and pricing
Usage logs
Meta Model API models: Muse Spark, Muse Image, and others, with no video generation model (checked October 30, 2026)

Get started

Image Generation & Editing APIs

Video Generation APIs

Text APIs

Multimodal & Audio APIs

Meta Muse Video API: Pricing and Integration

Create a token

Pricing

Choose between video models

How it works

Set up

Generate a video from text

Animate from a first frame or first and last frames

Generate from reference images

Make 20s and 30s clips or continue a video

Poll and download

Get the task

Download the video

Minimal Python client

API reference

Request fields

Task status

Errors

FAQ

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

Can I get 1080p video?

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

Can I resubmit after a timeout or failure?

How long are video links kept?

​Create a token

​Pricing

​Choose between video models

​How it works

​Set up

​Generate a video from text

​Animate from a first frame or first and last frames

​Generate from reference images

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

​Poll and download

​Get the task

​Download the video

​Minimal Python client

​API reference

​Request fields

​Task status

​Errors

​FAQ

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

​Can I get 1080p video?

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

​Can I resubmit after a timeout or failure?

​How long are video links kept?

​Related docs

Create a token

Pricing

Choose between video models

How it works

Set up

Generate a video from text

Animate from a first frame or first and last frames

Generate from reference images

Make 20s and 30s clips or continue a video

Poll and download

Get the task

Download the video

Minimal Python client

API reference

Request fields

Task status

Errors

FAQ

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

Can I get 1080p video?

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

Can I resubmit after a timeout or failure?

How long are video links kept?

Related docs