Home/Explore/WaveSpeed/Minimax H3/Reference To Video Lora

MiniMax H3 Open Weights R2V LoRA API

wavespeed-ai/minimax-h3/reference-to-video-lora

MiniMax H3 Open Weights Reference to Video with custom LoRA support 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. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

Reference to Video
Input

Drag & drop or click to upload

preview

Drag & drop or click to upload

preview
50% OFF

Idle

$0.18per run·~55 / $10

ExamplesView all

The man from <Picture 1>, alone, leans on the car from <Picture 2> at a desert gas station at sunset. He takes off his sunglasses, looks into the camera and says: "Fill it up. It's going to be a long night." Only one car in frame, no other people. Warm wind, engine idling.

Related Models

README

MiniMax H3 Reference-to-Video LoRA

MiniMax H3 Reference-to-Video LoRA Open Weights runs the open-weights edition of MiniMax H3 with LoRA support on WaveSpeedAI. Compared with the minimax/h3 endpoints, it uses its own 480p / 768p / 1080p resolution options and per-second pricing.

Why Choose This?

  • Open-weights MiniMax H3 workflow
    Use the open-weights edition of MiniMax H3 through WaveSpeedAI-hosted infrastructure.

  • Multimodal reference guidance
    Guide the output with reference images, reference videos, and reference audio.

  • Native stereo audio
    Generate visuals and synchronized stereo audio together in one pass.

  • LoRA support
    Load up to 3 LoRA weights per request, each with its own scale.

  • Reference-aware prompting
    Use tags such as <Picture 1>, <Video 1>, and <Audio 1> to assign clear roles to each input.

  • Flexible aspect ratios
    Supports landscape, vertical, square, classic, and cinematic aspect ratios.

Parameters

ParameterRequiredDescription
promptYesDesired video instructions with references addressed as <Picture 1>, <Video 1>, <Audio 1>, plus an Audio: line for soundtrack guidance.
reference_imagesNoUp to 9 reference image URLs.
reference_videosNoUp to 3 reference video URLs, usable at any output resolution. Their soundtracks are used automatically.
reference_audiosNoUp to 3 standalone reference audio URLs.
aspect_ratioNoOutput aspect ratio: 16:9, 9:16, 1:1, 4:3, 3:4, 21:9, or 9:21. Default: 16:9.
resolutionNoOutput resolution: 480p, 540p, 768p, or 1080p. Default: 768p.
durationNoOutput duration in seconds. Range: 3–15. Default: 5.
seedNoFixed seed for reproducible output.
lorasNoUp to 3 LoRA weights. Each item uses {path, scale}, where path is a LoRA file URL.

At least one of reference_images or reference_videos is required. reference_audios can guide sound, voice, rhythm, or ambience, but audio cannot be used as the only reference input.

Reference Rules

  • At least one reference image or reference video is required.
  • Reference audio cannot be provided alone.
  • Reference video soundtracks are picked up automatically.
  • Total reference video duration is capped at 15 seconds.
  • Longer reference video inputs may be trimmed within the 15-second budget.

How to Use

  1. Add reference media — Provide reference images or reference videos. Add reference audio when soundtrack, voice, rhythm, or ambience guidance is needed.
  2. Write the prompt — Use <Picture 1>, <Video 1>, and <Audio 1> tags to explain how each reference should be used.
  3. Choose aspect ratio — Select the output format that matches your target platform or composition.
  4. Choose resolution — Use 480p for lower-cost generation, 540p for a mid-price step up, 768p for the model's native canvas, or 1080p for full-HD output. Reference videos work at either; they are conformed to a 480p pixel budget internally, so they stay affordable at 768p.
  5. Set duration — Choose a duration from 3 to 15 seconds.
  6. Add LoRAs optional — Provide up to 3 LoRA files with individual scale values.
  7. Set seed optional — Use a fixed seed when reproducibility is needed.
  8. Submit — Generate the final MP4 with native stereo audio.

Pricing

Pricing is based on generated video duration, reference video duration, selected resolution, and the number of reference images and audios.

Price per second of output video (no reference media, by resolution):

ResolutionPer second of output (per=duration, 10 s)
480p$0.06 $0.03
540p$0.09 $0.045
768p$0.12 $0.06
1080p$0.24 $0.12

Total price of an output video without reference media, by resolution and duration:

Resolution5 s10 s15 s
480p$0.30 $0.15$0.60 $0.30$0.90 $0.45
540p$0.45 $0.225$0.90 $0.45$1.35 $0.675
768p$0.60 $0.30$1.20 $0.60$1.80 $0.90
1080p$1.20 $0.60$2.40 $1.20$3.60 $1.80

Reference video is billed per second at the same rate as output video for the chosen resolution, and its duration is rounded up to the next whole second. Total price of a default 5 s output with a reference video of 5 s (reference_videos.seconds=5) or 10 s (reference_videos.seconds=10):

Resolution5 s reference video10 s reference video
480p$0.60 $0.30$0.90 $0.45
540p$0.90 $0.45$1.35 $0.675
768p$1.20 $0.60$1.80 $0.90
1080p$2.40 $1.20$3.60 $1.80

Reference images and reference audio are charged per item, on top of the video price:

Add-onPrice
Each reference image: 1 image (reference_images.count=1) compared with no images (reference_images.count=0)$0.02 $0.01
Each reference audio: 1 audio (reference_audios.count=1) compared with no audio (reference_audios.count=0)$0.02 $0.01

Output duration and total reference video duration are each capped at 15 seconds for pricing, so reference videos longer than 15 seconds cost the same as 15 seconds.

Example: a 10 s 480p output (duration=10, resolution=480p) with 2 reference images (reference_images.count=2) and a 5 s reference video (reference_videos.seconds=5) costs $0.94 $0.47.

Default settings (5 s, 768p, no reference media) cost $0.60 $0.30 per run.

Best Use Cases

  • Reference-guided video generation — Use images, videos, and audio to guide identity, setting, motion, or sound.
  • Character-consistent scenes — Generate videos that follow character or style references.
  • Motion transfer and camera guidance — Use reference videos to guide motion, pacing, or camera rhythm.
  • Audio-guided generation — Use reference audio to guide music, voice, ambience, or sound direction.
  • LoRA-guided creative workflows — Combine references with LoRA weights for stronger style or subject control.
  • Social and cinematic clips — Generate short videos for vertical, landscape, square, or cinematic layouts.

Pro Tips

  • Assign a clear job to every reference in the prompt.
  • Use exact tags such as <Picture 1>, <Video 1>, and <Audio 1>.
  • Write prompts as a timeline with timestamped beats.
  • Add an Audio: line to control soundtrack, ambience, voice, and effects.
  • Use reference videos when motion, gesture, pacing, or camera behavior matters.
  • Use reference images when identity, subject appearance, setting, or style matters.
  • Use reference audio when rhythm, mood, voice, or sound design matters.
  • Use a fixed seed when comparing reference combinations or LoRA scale changes.
  • Keep LoRA combinations focused; too many strong LoRAs can reduce control.

Related Models

Reference

Note:This website uses AI models provided by third parties. Documentation prices are for reference and may be outdated. The Generate button shows an estimate; the final task charge prevails.

Minimax H3 Reference To Video Lora API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/wavespeed-ai/minimax-h3/reference-to-video-lora 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 Reference To Video Lora 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/reference-to-video-lora" \
  -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/reference-to-video-lora";
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/reference-to-video-lora", 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 Reference To Video Lora API — Frequently asked questions

What is the Minimax H3 Reference To Video Lora API?

Minimax H3 Reference To Video Lora is a WaveSpeedAI model for reference-guided video generation, exposed as a REST API on WaveSpeedAI. MiniMax H3 Open Weights Reference to Video with custom LoRA support 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. 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 Reference To Video Lora 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/reference-to-video-lora.

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

Minimax H3 Reference To Video Lora starts at $0.18 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 Reference To Video Lora 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/reference-to-video-lora.

How long does Minimax H3 Reference To Video Lora take to generate?

Reported generation time on WaveSpeedAI is around 111 seconds per request. This is an estimate, not a latency guarantee; queue time and input settings can change the total wait. live status is visible in the prediction record.

Can I use Minimax H3 Reference To Video Lora 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.

llms.txt — wavespeed-ai/minimax-h3/reference-to-video-lora for AI agents and LLMs