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

# Muse Video Reference to Video

> Muse Video Reference to Video keeps characters, products and scenes consistent across a 5-60 second 720p clip using 1-4 reference images, with native voice and sound.

`muse-video-r2v` generates a clip that stays faithful to the things you care about. Instead of pinning a single frame, you hand Muse Video one to four reference images — a character, a product, a location — and it composes the shot around them, holding identity and material detail across the whole clip.

## Model at a glance

| | |
| - | - |
| Public model ID | `muse-video-r2v` |
| Input | text + image (1-4) |
| Output | video with audio |
| Duration | 5, 10, 20, 30, 40, 50 or 60 seconds (default 5) |
| Resolution | 720p |
| Aspect ratio | `16:9`, `9:16`, `1:1`, `4:3`, `3:4` (default `16:9`) |
| Billing | per second of output |

## Parameters

| Parameter | Type | Default | Notes |
| - | - | - | - |
| `prompt` | string | — | Required, up to 4000 characters. Describe the action, not the references. |
| `image_urls` | string\[] | — | Required, 1-4 public image URLs. |
| `duration` | integer | `5` | Must be one of 5, 10, 20, 30, 40, 50, 60. |
| `aspect_ratio` | string | `16:9` | Output framing, independent of the reference images. |
| `resolution` | string | `720p` | 720p is the only supported tier. |
| `style_preset` | string | `none` | Same seven presets as text-to-video. |
| `generate_audio` | boolean | `true` | Set `false` to mute voices. |

## What each reference does

| References | Best for |
| - | - |
| 1 image | A single hero subject — one character or one product, in a new scene. |
| 2-3 images | Subject plus environment, so the model doesn't invent a backdrop. |
| 4 images | Multi-angle subject consistency, e.g. four sides of a product or a character sheet. |

Keep each reference focused on one thing. A photo that contains two competing subjects will pull the generated clip toward both.

## Prompting

Describe what happens, not what the subject looks like — the references already carry appearance. Naming the shot and the motion is usually enough.

```
The character walks through a rain-soaked night market, neon reflections
on wet asphalt, camera tracks at shoulder height, shallow focus
```

If a reference is a product, state the action rather than the object: "a hand lifts the bottle", not "a white glass bottle". Adjectives about the reference tend to be reapplied as style changes.

## Workflow

1. `POST /v1/videos/generations` with `image_urls` and a prompt.
2. Read `data.task_id`.
3. Poll `GET /v1/videos/status/{task_id}` until `completed`.
4. Download from `data.result`.

```bash theme={null}
curl https://api.apipod.ai/v1/videos/generations \
  -H "Authorization: Bearer $APIPOD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-video-r2v",
    "prompt": "The character walks through a rain-soaked night market, camera tracks at shoulder height",
    "image_urls": [
      "https://cdn.example.com/character-front.jpg",
      "https://cdn.example.com/night-market.jpg"
    ],
    "duration": 10,
    "aspect_ratio": "9:16",
    "style_preset": "cyberpunk_neon"
  }'
```

## Reference requirements

* Public HTTPS URLs only — expiring signed links and login-gated hosts fail at submission.
* Use one image per subject. Character sheets, product cutouts and location plates all work well.
* Real-person references should be well lit and front-facing; extreme crops lose identity detail.
* Reference images do not add to the bill on this model: billing is `duration × per-second price`.


## OpenAPI

````yaml api-reference/openapi/muse-video--muse-video-r2v.yaml POST /v1/videos/generations
openapi: 3.1.0
info:
  title: MU Video Reference to Video API
  version: 1.0.0
  description: >-
    MU Video Reference to Video builds 5-to-60-second 720p clips from a prompt
    plus 1-4 reference images, with five aspect ratios, seven style presets and
    native voice and sound. In APIPod, the public model ID is muse-video-r2v. It
    supports reference-to-video and returns results through asynchronous video
    tasks.
servers:
  - url: https://api.apipod.ai
    description: Production
security: []
paths:
  /v1/videos/generations:
    post:
      tags:
        - MU Video Reference to Video
      summary: Create Generation Task
      description: >-
        MU Video Reference to Video builds 5-to-60-second 720p clips from a
        prompt plus 1-4 reference images, with five aspect ratios, seven style
        presets and native voice and sound. In APIPod, the public model ID is
        muse-video-r2v. It supports reference-to-video and returns results
        through asynchronous video tasks.
      operationId: create-muse-video-muse-video-r2v
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: MU Video Reference to Video
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: muse-video-r2v
                prompt:
                  type: string
                  title: Prompt
                  description: >-
                    Describe the video to generate. Required, up to 4000
                    characters.
                  minLength: 1
                  maxLength: 4000
                image_urls:
                  type: array
                  title: Reference Images
                  description: >-
                    Required. 1-4 reference images of characters, products or
                    scenes the video should stay consistent with.
                  items:
                    type: string
                    description: Public image URL.
                  minItems: 1
                  maxItems: 4
                duration:
                  type: integer
                  title: Duration
                  description: Video duration in seconds.
                  enum:
                    - 5
                    - 10
                    - 20
                    - 30
                    - 40
                    - 50
                    - 60
                  default: 5
                aspect_ratio:
                  type: string
                  title: Aspect Ratio
                  description: Aspect ratio of the generated video.
                  enum:
                    - '16:9'
                    - '9:16'
                    - '1:1'
                    - '4:3'
                    - '3:4'
                  default: '16:9'
                resolution:
                  type: string
                  title: Resolution
                  description: Output resolution. MU Video currently supports 720p only.
                  enum:
                    - 720p
                  default: 720p
                style_preset:
                  type: string
                  title: Style Preset
                  description: Visual style preset applied to the video.
                  enum:
                    - none
                    - cinematic_realistic
                    - 2d_anime
                    - 3d_xianxia
                    - american_comic
                    - cyberpunk_neon
                    - ecommerce_ugc
                  default: none
                generate_audio:
                  type: boolean
                  title: Generate Audio
                  description: >-
                    Whether to generate voice and sound. Set to false to mute
                    voices.
                  default: true
              required:
                - model
                - prompt
                - image_urls
            example:
              model: muse-video-r2v
              prompt: A corgi surfing at sunset, cinematic, slow motion
              duration: 10
              aspect_ratio: '16:9'
              style_preset: cinematic_realistic
              generate_audio: true
      responses:
        '200':
          description: Task accepted
          content:
            application/json:
              schema:
                type: object
                title: Task Submit Response
                description: Standard response for task submission
                properties:
                  code:
                    type: integer
                  data:
                    type: object
                    title: Task Submit Data
                    description: Data content for task submission
                    properties:
                      task_id:
                        type: string
                        description: generatation task id
                  message:
                    type: string
                required:
                  - code
                  - message
                  - data
              example:
                code: 200
                message: success
                data:
                  task_id: vid_task_01JEXAMPLE
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: Shell
          label: cURL
          source: |-
            curl https://api.apipod.ai/v1/videos/generations \
              -H "Authorization: Bearer $APIPOD_API_KEY" \
              -H "Content-Type: application/json" \
              -d '{
              "model": "muse-video-r2v",
              "prompt": "A corgi surfing at sunset, cinematic, slow motion",
              "image_urls": ["https://cdn.example.com/ref-character.jpg", "https://cdn.example.com/ref-scene.jpg"],
              "duration": 10,
              "aspect_ratio": "16:9",
              "style_preset": "cinematic_realistic",
              "generate_audio": true
            }'
        - lang: Python
          label: Python
          source: |-
            import os
            import requests

            payload = {
              "model": "muse-video-r2v",
              "prompt": "A corgi surfing at sunset, cinematic, slow motion",
              "image_urls": ["https://cdn.example.com/ref-character.jpg", "https://cdn.example.com/ref-scene.jpg"],
              "duration": 10,
              "aspect_ratio": "16:9",
              "style_preset": "cinematic_realistic",
              "generate_audio": True
            }

            response = requests.post(
                "https://api.apipod.ai/v1/videos/generations",
                headers={
                    "Authorization": f"Bearer {os.environ['APIPOD_API_KEY']}",
                    "Content-Type": "application/json",
                },
                json=payload,
                timeout=60,
            )
            response.raise_for_status()
            print(response.json())
        - lang: Go
          label: Go
          source: |-
            package main

            import (
                "bytes"
                "encoding/json"
                "fmt"
                "net/http"
                "os"
            )

            func main() {
                payload := map[string]any{}
                if err := json.Unmarshal([]byte(`{
              "model": "muse-video-r2v",
              "prompt": "A corgi surfing at sunset, cinematic, slow motion",
              "image_urls": ["https://cdn.example.com/ref-character.jpg", "https://cdn.example.com/ref-scene.jpg"],
              "duration": 10,
              "aspect_ratio": "16:9",
              "style_preset": "cinematic_realistic",
              "generate_audio": true
            }`), &payload); err != nil {
                    panic(err)
                }
                body, err := json.Marshal(payload)
                if err != nil {
                    panic(err)
                }

                req, err := http.NewRequest(http.MethodPost, "https://api.apipod.ai/v1/videos/generations", bytes.NewReader(body))
                if err != nil {
                    panic(err)
                }
                req.Header.Set("Authorization", "Bearer "+os.Getenv("APIPOD_API_KEY"))
                req.Header.Set("Content-Type", "application/json")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                    panic(err)
                }
                defer resp.Body.Close()
                fmt.Println(resp.Status)
            }
        - lang: Rust
          label: Rust
          source: |-
            use reqwest::Client;
            use serde_json::json;
            use std::env;

            #[tokio::main]
            async fn main() -> Result<(), Box<dyn std::error::Error>> {
                let payload = json!({
              "model": "muse-video-r2v",
              "prompt": "A corgi surfing at sunset, cinematic, slow motion",
              "image_urls": ["https://cdn.example.com/ref-character.jpg", "https://cdn.example.com/ref-scene.jpg"],
              "duration": 10,
              "aspect_ratio": "16:9",
              "style_preset": "cinematic_realistic",
              "generate_audio": true
            });
                let response = Client::new()
                    .post("https://api.apipod.ai/v1/videos/generations")
                    .bearer_auth(env::var("APIPOD_API_KEY")?)
                    .json(&payload)
                    .send()
                    .await?
                    .error_for_status()?;

                println!("{}", response.text().await?);
                Ok(())
            }
        - lang: JavaScript
          label: JavaScript
          source: >-
            const response = await
            fetch("https://api.apipod.ai/v1/videos/generations", {
              method: "POST",
              headers: {
                Authorization: `Bearer ${process.env.APIPOD_API_KEY}`,
                "Content-Type": "application/json",
              },
              body: JSON.stringify(
              {
                "model": "muse-video-r2v",
                "prompt": "A corgi surfing at sunset, cinematic, slow motion",
                "image_urls": ["https://cdn.example.com/ref-character.jpg", "https://cdn.example.com/ref-scene.jpg"],
              "image_urls": ["https://cdn.example.com/ref-character.jpg", "https://cdn.example.com/ref-scene.jpg"],
                "duration": 10,
                "aspect_ratio": "16:9",
                "style_preset": "cinematic_realistic",
                "generate_audio": true
              }
              ),
            });


            if (!response.ok) {
              throw new Error(`APIPod request failed: ${response.status} ${await response.text()}`);
            }


            console.log(await response.json());
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: APIPod API key
      description: Use your APIPod API key as a Bearer token in the Authorization header.

````

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