MiniMax H3 Singularity Reference-to-Video API

Name: MiniMax H3 Singularity Reference-to-Video
Brand: wavespeed-ai
SKU: wavespeed-ai/minimax-h3-singularity/reference-to-video
Price: 0.15 USD
Availability: InStock

ExamplesView all

Ultra-realistic cinematic street scene. A middle-aged male hot dog vendor is pushing a street food cart across a busy city intersection in daylight. Keep the urban background, crosswalk, pedestrians, and overall composition stable. As he pushes the cart forward, one wheel suddenly catches on an uneven patch of road or a small bump in the pavement. The cart is briefly jolted and shaken, causing the umbrella, condiments, and items on the cart to wobble naturally. The vendor’s body reacts instantly — he stumbles slightly, tightens his grip, and leans his body to steady the cart before continuing forward. The motion should feel realistic and physical, with a clear sense of weight, inertia, and a sudden interruption in movement.

README

MiniMax H3 Singularity Reference-to-Video (Open Weights)

Run the open-weights edition of MiniMax H3 Singularity on WaveSpeedAI's own GPU infrastructure. This endpoint is independently hosted and provides 480p, 540p, 768p, and 1080p output tiers with resolution-based per-second pricing.

Why Choose This?

Multimodal reference-to-video generation
Guide video generation with images, videos, audio, or combinations of multiple reference types.
Up to 9 reference images
Use multiple visual references for characters, objects, environments, composition, or style.
Up to 3 reference videos
Provide motion and video context through multiple reference clips.
Reference video audio support
Soundtracks from reference videos are used automatically during generation.
Standalone audio references
Add up to 3 separate audio references for additional voice, music, or sound guidance.
Native audio generation
Audio is generated together with the video rather than requiring a separate generation step.
Four resolution tiers
Choose 480p, 540p, 768p, or 1080p depending on cost and output requirements.
Up to 15 seconds of generated video
Generate clips from 3 to 15 seconds.

How to Use References

Address references directly in the prompt using angle-bracket tags:

Images: <Picture 1> through <Picture 9>
Videos: <Video 1> through <Video 3>
Standalone audio: <Audio 1> through <Audio 3>

Tags should be written with the angle brackets exactly as shown.

Assigning a clear purpose to each reference helps make the generation instruction easier to interpret.

For example:

Use the character from <Picture 1>, place them in the environment from <Picture 2>, and follow the camera movement of <Video 1>.

Reference numbering follows the order in which inputs are supplied within each reference type.

Reference video soundtracks are used automatically.

How to Write a Strong Prompt

For more controlled generation, structure the prompt around the scene progression:

Define references — State which image, video, or audio reference should guide each part of the generation.
Describe the timeline — Explain how the action develops throughout the clip.
Specify camera movement — Describe pans, tracking, zooms, or static camera behavior.
Describe audio direction — Explain the desired dialogue, music, ambience, or sound behavior.
Specify visible text carefully — Put exact on-screen wording in quotes when readable text matters.

Example:

Use the character from <Picture 1> and the environment from <Picture 2>.
[0s-3s] The character stands on the balcony while the camera slowly moves forward.
[3s-6s] They turn toward the camera and smile.
Match the camera movement of <Video 1>.
Audio: quiet city ambience with natural environmental sound.

Parameters

Parameter	Required	Description
prompt	Yes	Text description of the desired video. Reference inputs can be addressed as `<Picture 1>`–`<Picture 9>`, `<Video 1>`–`<Video 3>`, and `<Audio 1>`–`<Audio 3>`. Audio is generated natively together with the video.
reference_images	No	Up to `9` reference image URLs.
reference_videos	No	Up to `3` reference video URLs. Reference videos can be used at any output resolution. Their soundtracks are used automatically. Total reference-video duration is limited to a `15`-second budget; longer inputs are truncated fairly.
reference_audios	No	Up to `3` standalone reference audio URLs. Each audio input is trimmed to a maximum of `15` seconds.
aspect_ratio	No	Output aspect ratio: `16:9`, `9:16`, `1:1`, `4:3`, `3:4`, `21:9`, or `9:21`. Default: `16:9`.
resolution	No	Output resolution: `480p`, `540p`, `768p`, or `1080p`. Default: `768p`.
duration	No	Output video duration in seconds. Supported values: `3–15` whole seconds. Default: `5`.
seed	No	Random seed for generation. Use `-1` for a random seed.

Pricing

The generated output video and reference-video duration use the same resolution-dependent per-second rate.

Resolution	Per 5s	Per Billed Second
480p	$0.25	$0.05
540p	$0.375	$0.075
768p	$0.50	$0.10
1080p	$1.00	$0.20

Reference Pricing

Reference Type	Price
Reference image	$0.02 each
Standalone reference audio	$0.02 each
Reference video	Same per-second rate as the selected output resolution

Total reference-video duration is capped at 15 seconds for billing and rounded up to the next whole second.

Standalone reference_audios are charged by count, not duration.

Example

Component	Cost
10s output video	$0.50
2 reference images	$0.04
5s reference video	$0.25
Total	$0.79

Best Use Cases

Character consistency — Use reference images to guide recurring characters or subjects.
Motion guidance — Use reference videos to guide movement, action, or camera behavior.
Voice and audio reference workflows — Add standalone audio references alongside visual guidance.
Multi-reference storytelling — Combine characters, environments, motion, and audio from different inputs.
Cinematic video generation — Coordinate visual references, camera direction, timeline, and native audio in one generation.
Creative prototyping — Experiment with combinations of visual, motion, and audio references.

Pro Tips

Explicitly assign a purpose to each reference in the prompt.
Use tags such as <Picture 1> and <Video 1> instead of vague descriptions like "the first image."
Keep the timeline clear when multiple actions need to happen in sequence.
Use reference videos when motion or camera behavior matters more than a static visual reference.
Keep total reference-video content focused because only up to 15 seconds is used.
Use 480p for lower-cost testing before moving to 768p or 1080p.
Set a fixed seed when comparing prompt or reference changes.

Notes

prompt is the only schema-required parameter.
Up to 9 reference images are supported.
Up to 3 reference videos are supported.
Up to 3 standalone reference audio inputs are supported.
Total reference-video duration is limited to 15 seconds.
Each standalone reference audio input is trimmed to a maximum of 15 seconds.
Reference video soundtracks are used automatically.
duration supports integer values from 3 to 15.
resolution defaults to 768p.
aspect_ratio defaults to 16:9.
seed=-1 selects a random seed.

Related Models

MiniMax H3 Singularity Reference-to-Video — Generate video with multimodal image, video, and audio reference guidance.
MiniMax H3 Singularity Reference-to-Video LoRA — Use the Singularity reference-to-video workflow with LoRA-based customization.

Minimax H3 Singularity Reference To Video API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/wavespeed-ai/minimax-h3-singularity/reference-to-video with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for Minimax H3 Singularity Reference To Video below.

HTTP example

set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "aspect_ratio": "16:9",
    "resolution": "768p",
    "duration": 5
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/wavespeed-ai/minimax-h3-singularity/reference-to-video" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
  printf 'Submission response did not contain a prediction id
' >&2
  exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done

Node.js example

const submitUrl = "https://api.wavespeed.ai/api/v3/wavespeed-ai/minimax-h3-singularity/reference-to-video";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "prompt": "A cinematic shot of a city at sunset, soft golden light",
        "aspect_ratio": "16:9",
        "resolution": "768p",
        "duration": 5
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
  await new Promise(resolve => setTimeout(resolve, 2000));
}

Python example

import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "aspect_ratio": "16:9",
    "resolution": "768p",
    "duration": 5
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/wavespeed-ai/minimax-h3-singularity/reference-to-video", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout", "deleted"}:
        raise RuntimeError(result)
    time.sleep(2)

Minimax H3 Singularity Reference To Video API — Frequently asked questions

What is the Minimax H3 Singularity Reference To Video API?

Minimax H3 Singularity Reference To Video is a WaveSpeedAI model for reference-guided video generation, exposed as a REST API on WaveSpeedAI. MiniMax H3 Singularity Open Weights Reference to Video generates coherent 480P / 540P / 768P videos from prompts and multimodal references, guided by up to 9 reference images, 3 reference videos, and 3 reference audios, with native stereo audio and flexible reference-based video generation on WaveSpeedAI infrastructure. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the Minimax H3 Singularity Reference To Video API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates Python, JavaScript, and cURL examples for submitting requests and polling results. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/wavespeed-ai/minimax-h3-singularity-reference-to-video.

How much does Minimax H3 Singularity Reference To Video cost per run or per second?

Minimax H3 Singularity Reference To Video starts at $0.15 per run or per second. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does Minimax H3 Singularity Reference To Video accept?

Key inputs: `prompt`, `aspect_ratio`, `resolution`, `duration`, `seed`, `reference_images`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/wavespeed-ai/minimax-h3-singularity-reference-to-video.

How do I get started with the Minimax H3 Singularity Reference To Video API?

Sign up for a free WaveSpeedAI account to claim starter credits, copy your API key from /accesskey, then call the endpoint shown in the API tab of the playground. The playground also auto-generates a code sample in Python, JavaScript, or cURL for the parameters you've set.

Can I use Minimax H3 Singularity Reference To Video outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (WaveSpeedAI). Check the provider's applicable terms and WaveSpeedAI's Terms of Service before commercial use.

ExamplesView all

Related Models

README

MiniMax H3 Singularity Reference-to-Video (Open Weights)

Why Choose This?

How to Use References

How to Write a Strong Prompt

Parameters

Pricing

Reference Pricing

Example

Best Use Cases

Pro Tips

Notes

Related Models

Minimax H3 Singularity Reference To Video API — Quick start

Minimax H3 Singularity Reference To Video API — Frequently asked questions

More from WaveSpeed

More Reference to Video models