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.
Idle
$0.18per run·~55 / $10
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.
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.
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.
| Parameter | Required | Description |
|---|---|---|
| prompt | Yes | Desired video instructions with references addressed as <Picture 1>, <Video 1>, <Audio 1>, plus an Audio: line for soundtrack guidance. |
| reference_images | No | Up to 9 reference image URLs. |
| reference_videos | No | Up to 3 reference video URLs, usable at any output resolution. Their soundtracks are used automatically. |
| reference_audios | No | Up to 3 standalone reference audio URLs. |
| 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 duration in seconds. Range: 3–15. Default: 5. |
| seed | No | Fixed seed for reproducible output. |
| loras | No | Up 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.
<Picture 1>, <Video 1>, and <Audio 1> tags to explain how each reference should be used.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.3 to 15 seconds.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):
| Resolution | Per second of output (per=duration, 10 s) |
|---|---|
| 480p | |
| 540p | |
| 768p | |
| 1080p |
Total price of an output video without reference media, by resolution and duration:
| Resolution | 5 s | 10 s | 15 s |
|---|---|---|---|
| 480p | |||
| 540p | |||
| 768p | |||
| 1080p |
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):
| Resolution | 5 s reference video | 10 s reference video |
|---|---|---|
| 480p | ||
| 540p | ||
| 768p | ||
| 1080p |
Reference images and reference audio are charged per item, on top of the video price:
| Add-on | Price |
|---|---|
Each reference image: 1 image (reference_images.count=1) compared with no images (reference_images.count=0) | |
Each reference audio: 1 audio (reference_audios.count=1) compared with no audio (reference_audios.count=0) |
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.
<Picture 1>, <Video 1>, and <Audio 1>.Audio: line to control soundtrack, ambience, voice, and effects.seed when comparing reference combinations or LoRA scale changes.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.
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
doneconst 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));
}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 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.
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.
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.
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.
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.
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.