Close documentary shot at a desert archaeological excavation at sunrise. An adult archaeologist in a faded burgundy scarf kneels over a small mosaic, carefully sweeping loose sand away with a soft brush. Several intense cobalt tiles emerge under the brush. A light gust lifts the edge of the scarf while the archaeologist pauses and leans closer with a small surprised smile. One gentle rack focus from the moving brush to the eyes; realistic sand particles and restrained hand movement. Native dry brushing and faint wind, no speech or music. Five seconds, a single clear discovery beat, no written inscriptions, subtitles, advertising or logos.
MiniMax H3 Max Turbo Text to Video API
minimax/h3-max-turbo/text-to-videoMiniMax H3 Max Turbo Text to Video turns text into coherent 5–15 second videos with synchronized native stereo audio and fast generation. It follows physical motion while rendering subtle changes in light and shadow.
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-turbo/text-to-video",
"input": {
"prompt": "Five-second continuous sports-documentary shot in a quiet indoor basketball gym at late afternoon. An adult wheelchair basketball player in a plain teal jersey rolls forward, bounces the basketball once, turns the chair a quarter turn with a decisive push on the rim, and makes a chest pass toward a teammate just off camera. Low camera tracks alongside, keeping the athlete's face, wheels and ball visible. Believable wheel rotation, hand-to-ball contact and body balance. Native stereo bounce, tire squeak and a short exhale timed to the pass. Confident joyful concentration, no montage, no slow motion, no brands, captions or 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": "YI6IXQEOOYMH4QWB",
"status": "running",
"created_time": "2026-10-11T22:57:39"
}
}{
"code": 200,
"data": {
"task_id": "YI6IXQEOOYMH4QWB",
"status": "finished",
"files": [
{
"file_url": "https://cdn.vidgo.ai/apis/models/minimax/h3-max-turbo/text-to-video/v1/01/output.mp4",
"file_type": "video"
}
],
"created_time": "2026-10-11T22:57:39",
"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-turbo/text-to-video",
"input": {
"prompt": "Five-second continuous sports-documentary shot in a quiet indoor basketball gym at late afternoon. An adult wheelchair basketball player in a plain teal jersey rolls forward, bounces the basketball once, turns the chair a quarter turn with a decisive push on the rim, and makes a chest pass toward a teammate just off camera. Low camera tracks alongside, keeping the athlete's face, wheels and ball visible. Believable wheel rotation, hand-to-ball contact and body balance. Native stereo bounce, tire squeak and a short exhale timed to the pass. Confident joyful concentration, no montage, no slow motion, no brands, captions or 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 | — | minimax/h3-max-turbo/text-to-video |
| callback_url | string (URL) | No | — | HTTP(S) |
| input | object | Yes | — | An input object containing generation parameters such as prompt, duration, and resolution. |
| input.prompt | string | Yes | — | 1–50,000 characters |
| input.duration | integer | No | 5 | 5–15 seconds, integer |
| input.resolution | string | No | 768p | 480p | 768p | 1080p |
| input.enable_safety_checker | boolean | No | true | true | false |
| input.aspect_ratio | string | No | 16:9 | 21:9 | 16:9 | 4:3 | 1:1 | 3:4 | 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 was accepted and is waiting to begin.
runningGeneration is in progress. Continue polling the same task_id.
finishedGeneration succeeded. Read the video URL from data.files[].file_url.
failedGeneration stopped with an error. Read data.error_message and do not continue polling.
Polling and Errors
- AuthenticationA 401 response indicates a missing or invalid Bearer API key. Correct the credential before retrying.
- ValidationA 400 response means the request is invalid. Read the response message and correct the named field.
- Polling intervalStart around every 2 seconds. Increase the interval gradually for long-running tasks.
- Terminal statesContinue only for not_started or running. Stop immediately on finished or failed.
- Callback optionProvide callback_url to receive the final asynchronous result; otherwise use the status endpoint.
Model Specifications
| Specification | Value | Description |
|---|---|---|
| Model | minimax/h3-max-turbo/text-to-video | Model identifier for the asynchronous text-to-video endpoint |
| Duration | 5–15 | Whole seconds; defaults to 5 seconds |
| Resolution | 480p | 768p | 1080p | Defaults to 768p |
| Pricing | 5 / 8 / 16 credits/s | Per-second pricing by resolution tier (480p / 768p / 1080p) |
Related Models
MiniMax H3 Max Turbo Text to Video API FAQ
What is the MiniMax H3 Max Turbo Text to Video API?
MiniMax H3 Max Turbo Text to Video is a text-to-video model developed by MiniMax. It quickly generates high-quality 5–15 second videos from text prompts at 480p, 768p, or 1080p in six cinematic aspect ratios, with native synchronized two-channel ambient sound. Advanced post-training distillation increases inference throughput and reduces generation time while preserving faithful adherence to physical motion and camera instructions in the prompt. Access it programmatically through the API or try it directly in the playground above.
How does MiniMax H3 Max Turbo differ from the base H3 Max?
MiniMax H3 Max Turbo is a deeply distilled, post-trained version of the flagship H3 Max. It generates about 2 times faster and costs half as much across all resolution tiers, making it suitable for high-throughput batch production and fast creative exploration. Turbo focuses on text-to-video and image-to-video generation; it does not include the base model's multimodal Reference to Video capability.
Does MiniMax H3 Max Turbo Text to Video natively support audio generation?
Yes. The model natively generates synchronized audio and video. It uses the prompt's actions, surroundings, and scene descriptions to synthesize closely matching stereo background audio and action effects alongside the visuals, without requiring additional effects in post-production.
Is MiniMax H3 Max Turbo's 1080p output natively rendered?
The 1080p tier is enhanced through latent refinement upsampling from 768p, rather than a native 1080p base render. For maximum rendering efficiency and value, use the native 768p tier. Choose 1080p when you need higher pixel density for HD delivery.
Which aspect ratios does MiniMax H3 Max Turbo Text to Video support?
The model natively supports six fixed aspect ratios: 21:9, 16:9, 4:3, 1:1, 3:4, and 9:16. It does not support adaptive. Landscape 16:9 suits cinematic storytelling and commercials, 9:16 suits short-video platforms, and 1:1 suits social feeds. Choose the ratio before writing the prompt so the composition naturally fits the subject.
How is MiniMax H3 Max Turbo Text to Video billed?
The API bills per second based only on the requested duration parameter and selected resolution: 480p costs 5 credits per second (about $0.025/second), 768p costs 8 credits per second (about $0.040/second), and 1080p costs 16 credits per second (about $0.080/second). A default 5-second 768p video costs 40 credits ($0.200). Before submission, the playground's Run button shows a live cost estimate based on the selected settings.
How can I improve prompt adherence for complex scenes?
Organize the prompt in layers: "subject features and background -> main subject action -> camera movement and shot size -> lighting, atmosphere, and style." Keep the 5–15 second video focused on one coherent main action rather than unrelated or conflicting events. When timing matters, describe how the action progresses over time.















