A single uninterrupted lateral tracking shot in an old sunlit fencing salle. Two adult women in plain white fencing uniforms and protective masks face each other on a wooden piste. The nearer fencer advances one step and lunges; her opponent makes one clean parry, the blades briefly contact, and both settle back into guard. Keep the two people distinct with anatomically correct arms and stable swords. Crisp footwork, believable fabric momentum, the metallic tap exactly on blade contact and soft rubber soles on wood. Controlled athletic rehearsal, no injury. Five seconds, natural cinema, no slow motion, no captions, logos or text.
MiniMax H3 Max Text to Video API
minimax/h3-max/text-to-videoMiniMax H3 Max Text to Video turns text prompts into cinematic video with native stereo audio, faster-than-real-time generation, and precise instruction following. It renders complex camera work and physical motion with fine detail across multiple resolutions and common aspect ratios.
Examples
REST API
Quick Start
Make your first request in three steps. Start with the short example, confirm that it returns a task_id, then retrieve the generated video.
Connect to the Vidgo API
Create an API key, keep it on your server, and send it in the Authorization header as a Bearer token.
- Endpoint
- POST
https://api.vidgo.ai/api/generate/submit - Authentication
- Authorization: Bearer VIDGO_API_KEY
Submit one generation task
Choose a language and run the short example. A successful submission returns a task_id; it does not wait for the video to finish.
curl --request POST \
--url "https://api.vidgo.ai/api/generate/submit" \
--header "Authorization: Bearer $VIDGO_API_KEY" \
--header "Content-Type: application/json" \
--data '{
"model": "minimax/h3-max/text-to-video",
"input": {
"prompt": "One continuous cinematic shot inside a blue glacier cave. A female glaciologist in a mustard expedition jacket stands beside translucent ice. A deep crack echoes; she freezes, slowly raises her head toward the sound, and whispers, \"Did you hear that?\" A few tiny ice crystals drift down through her headlamp beam. The camera gently pushes from a waist-up view into her concerned face; keep the geography and her identity stable. Realistic breath vapor, subtle human expression, detailed blue subsurface light. Native stereo cave echo and quiet ice creaks, clearly synchronized brief English speech. Five seconds, restrained action, no collapse. No subtitles, logos or on-screen text.",
"duration": 5,
"resolution": "768p",
"enable_safety_checker": true,
"aspect_ratio": "16:9"
}
}'Wait for the result
Use the returned task_id to check the same task until it reaches finished or failed. On success, read data.files[].file_url.
Track status
GET https://api.vidgo.ai/api/generate/status/{task_id}Poll about every 2 seconds while the status is not_started or running. Stop on finished or failed; on success, read data.files[].file_url. For long-running jobs, increase the interval gradually, or add callback_url to the submit request to receive the final result asynchronously.
not_startedrunningfinishedfailed{
"code": 200,
"data": {
"task_id": "5V85RY0L6GPFZ1GY",
"status": "running",
"created_time": "2026-10-11T22:58:24"
}
}{
"code": 200,
"data": {
"task_id": "5V85RY0L6GPFZ1GY",
"status": "finished",
"files": [
{
"file_url": "https://cdn.vidgo.ai/apis/models/minimax/h3-max/text-to-video/v1/01/output.mp4",
"file_type": "video"
}
],
"created_time": "2026-10-11T22:58:24",
"error_message": null,
"progress": 100
}
}Complete runnable example
Open this after the three-step flow is clear. It combines submission, polling, terminal-state handling, and result extraction in one script.
set -euo pipefail
: "${VIDGO_API_KEY:?Set VIDGO_API_KEY in your environment}"
REQUEST_BODY=$(cat <<'JSON'
{
"model": "minimax/h3-max/text-to-video",
"input": {
"prompt": "One continuous cinematic shot inside a blue glacier cave. A female glaciologist in a mustard expedition jacket stands beside translucent ice. A deep crack echoes; she freezes, slowly raises her head toward the sound, and whispers, \"Did you hear that?\" A few tiny ice crystals drift down through her headlamp beam. The camera gently pushes from a waist-up view into her concerned face; keep the geography and her identity stable. Realistic breath vapor, subtle human expression, detailed blue subsurface light. Native stereo cave echo and quiet ice creaks, clearly synchronized brief English speech. Five seconds, restrained action, no collapse. No subtitles, logos or on-screen text.",
"duration": 5,
"resolution": "768p",
"enable_safety_checker": true,
"aspect_ratio": "16:9"
}
}
JSON
)
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
--request POST \
--url "https://api.vidgo.ai/api/generate/submit" \
--header "Authorization: Bearer $VIDGO_API_KEY" \
--header "Content-Type: application/json" \
--data "$REQUEST_BODY")
TASK_ID=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.data.task_id // .task_id // empty')
if [ -z "$TASK_ID" ]; then
printf 'Submit response did not include task_id:
%s
' "$SUBMIT_RESPONSE" >&2
exit 1
fi
while true; do
STATUS_RESPONSE=$(curl --silent --show-error --fail-with-body \
--url "https://api.vidgo.ai/api/generate/status/$TASK_ID" \
--header "Authorization: Bearer $VIDGO_API_KEY")
STATUS=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.data.status // .status // empty')
case "$STATUS" in
finished)
printf '%s' "$STATUS_RESPONSE" | jq -r '(.data.files // .files // [])[]?.file_url'
break
;;
failed)
printf '%s' "$STATUS_RESPONSE" | jq -r '.data.error_message // .error_message // "Generation failed"' >&2
exit 1
;;
not_started|running)
sleep 2
;;
*)
printf 'Unexpected task status: %s
' "$STATUS" >&2
exit 1
;;
esac
doneRequest Parameters
model and callback_url belong at the request root; generation parameters belong inside input.
| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| model | string | Yes | — | Fixed to minimax/h3-max/text-to-video. |
| callback_url | string (URL) | No | — | A public HTTP(S) URL for receiving task completion notifications. |
| input | object | Yes | — | An object containing the parameters required for generation. |
| input.prompt | string | Yes | — | A natural-language description of the scene and camera movement. The original input must not exceed 50,000 characters, including leading and trailing whitespace, and must not be empty after trimming. |
| input.duration | integer | No | 5 | Generation duration: any whole number from 5–15 seconds. |
| input.resolution | string | No | 768p | Video resolution: 480p, 768p, or 1080p. |
| input.enable_safety_checker | boolean | No | true | Whether to enable the generated-content safety checker. |
| input.aspect_ratio | string | No | 16:9 | Options: 21:9, 16:9, 4:3, 1:1, 3:4, or 9:16. |
Response Fields
Submission returns the task identity immediately. Status responses add progress, output files, or a failure message as the task advances.
| Field | Type | Description |
|---|---|---|
| code | integer | Application result code. Successful responses use 0 or 200. |
| message | string | Human-readable response or error message when present. |
| data.task_id | string | Task identifier used in the status endpoint path. |
| data.status | string | Current state: not_started, running, finished, or failed. |
| data.created_time | string | Task creation time in date-time format. |
| data.progress | number | Completion percentage when the provider reports progress. |
| data.files[] | array | Generated output files returned after a successful task. |
| data.files[].file_url | string | Public URL of the generated video. |
| data.files[].file_type | string | Generated file type, such as video. |
| data.files[].watermark_url | string | null | Watermarked output URL when one is available. |
| data.error_message | string | null | Failure detail when status is failed. |
Task Lifecycle
Treat not_started and running as non-terminal states. finished and failed are terminal alternatives; stop polling when either is returned.
not_startedThe task has been accepted and is queued to start.
runningThe video is being generated. Continue polling the status endpoint.
finishedThe task is complete. Read the video URL from data.files[].file_url.
failedGeneration failed. Read data.error_message for details and stop polling.
Polling and Errors
- Authentication401 indicates a missing or invalid Bearer API Key. Check your key in the dashboard before retrying.
- Validation400 indicates invalid request parameters. Check that the prompt length and enum values meet the API contract.
- Polling intervalPoll the status every 2 seconds. For longer tasks, use exponential backoff to gradually increase the interval to 5 seconds.
- Terminal statesPoll only while the status is not_started or running. Stop immediately on finished or failed.
- Callback optionProvide callback_url to receive an automatic notification when generation finishes, without continuous polling.
Model Specifications
| Specification | Value | Description |
|---|---|---|
| Model | minimax/h3-max/text-to-video | Model identifier for asynchronous text-to-video generation. |
| Duration | 5–15 | Whole seconds; defaults to 5 seconds. |
| Resolution | 480p | 768p | 1080p | Natively supports multiple resolution tiers; defaults to 768p. |
| Pricing | 10 / 16 / 32 credits/s | Corresponds to the 480p / 768p / 1080p tiers, respectively. |
Related Models
MiniMax H3 Max Text to Video API FAQ
What is the MiniMax H3 Max Text to Video API?
MiniMax H3 Max Text to Video is a text-to-video model from MiniMax, optimized through extensive post-training. It generates cinematic 5–15 second videos from text alone, with throughput faster than real time, strong adherence to complex instructions, and native synchronized stereo audio. Its spatiotemporal diffusion architecture preserves plausible physical motion and temporal continuity while rendering detailed lighting and camera paths. Access it programmatically through the API or try it directly in the playground above.
How fast is MiniMax H3 Max Text to Video?
With optimized inference architecture and compute scheduling, the core generation of a 5-second 768p video can finish in about 3 seconds under typical network and server conditions. Actual end-to-end time includes queuing and scheduling. Its high throughput, well beyond real-time speed, helps shorten turnaround in production pipelines.
How does MiniMax H3 Max Text to Video generate native audio?
The model synthesizes two-channel stereo audio alongside the video, without requiring a separate voice or sound-effects model in post-production. Add specific descriptions of ambient sounds and action effects, such as doors opening or closing, wind and rain, or engines, to the prompt. The generated audio aligns naturally and precisely with the timing of the visual actions.
Which durations and resolutions does MiniMax H3 Max Text to Video support?
Choose any whole-second duration from 5–15 seconds, with a default of 5 seconds. Resolution tiers are 480p for standard-definition tests, 768p for standard HD output (default), and 1080p for full HD commercial output. All three tiers support six aspect ratios: 21:9, 16:9, 4:3, 1:1, 3:4, and 9:16.
How is MiniMax H3 Max Text to Video billed?
The API bills by the requested duration parameter in seconds, with the credit rate determined by resolution: 480p costs 10 credits per second (about $0.050/second), 768p costs 16 credits per second (about $0.080/second), and 1080p costs 32 credits per second (about $0.160/second). For example, a 5-second 768p video costs 80 credits. The dashboard dynamically estimates the required credits before submission.
How should I choose between MiniMax H3 Max and the original MiniMax H3?
Choose MiniMax H3 Max for higher throughput, fast creative iteration, faithful prompt details, and native synchronized stereo audio. If your project depends on native 2K or 4K ultra-high resolution, the original MiniMax H3 is recommended.
How can I write prompts to control camera movement precisely?
Use cinematography terms to specify placement and movement, such as "the camera slowly tracks from a wide shot into a medium shot," "a low-angle tracking shot close to the ground," or "the camera orbits the character." Describe subject actions and camera paths separately, then add depth-of-field and lighting-direction cues to help the model follow your shot design.















