MiniMax H3 API: Pricing, Endpoints & Code Examples

MiniMax H3 provides a multimodal video generation API for text-to-video, first/last-frame image-to-video and reference-based generation with images, videos and audio. The current API uses the MiniMax-H3 model through the v2 video generation endpoint and supports 4–15 second output at 768P or 2K.

Last verified: August 17, 2026

By Jaysean BrambilaFounder of MiniMax3.org · AI Video & Generative AIUpdated:
Model
MiniMax-H3
Endpoint
POST /v2/video_generation
Resolution
768P / 2K
Duration
4–15 seconds
Page contents

MiniMax H3 API Quick Answer

The MiniMax H3 API is available through MiniMax's pay-as-you-go API platform. Use model MiniMax-H3 with POST /v2/video_generation to create an asynchronous video generation task. The API accepts text plus optional image, video or audio inputs and currently supports 768P or 2K videos from 4 to 15 seconds.

Current output list pricing is $0.08 per second at 768P and $0.13 per second at 2K.

Current MiniMax H3 API facts
FieldCurrent MiniMax H3 API
ModelMiniMax-H3
Create endpointPOST /v2/video_generation
AuthenticationBearer API key
ProcessingAsynchronous
InputText, image, video, audio
Output resolution768P / 2K
Duration4–15 seconds
768P output price$0.08 / second
2K output price$0.13 / second

Pricing and API behavior were checked against MiniMax's current developer documentation on August 17, 2026. API specifications can change; verify production integrations against the latest provider documentation.

MiniMax H3 API Pricing

MiniMax currently bills H3 video output by generated video duration. At the current pay-as-you-go list price, 768P output costs $0.08 per second and 2K output costs $0.13 per second.

Reference inputs can add separate charges. Audio references are currently free. The first five input images are free, with additional images billed at $0.04 each. Reference video is billed by the duration of the input video at the same per-second rate associated with the selected output resolution.

MiniMax H3 API list prices
API usageCurrent list price
H3 output — 768P$0.08 / second
H3 output — 2K$0.13 / second
Reference audioFree
Reference images 1–5Free
Each image after first 5$0.04
Reference video with 768P output$0.08 / input second
Reference video with 2K output$0.13 / input second
768P → 2K regeneration$0.05 / output second

How Much Does a MiniMax H3 API Video Cost?

MiniMax H3 output-only cost examples
Duration768P2K
4 sec$0.32$0.52
5 sec$0.40$0.65
10 sec$0.80$1.30
15 sec$1.20$1.95

Output-only examples. Reference video or additional image charges can increase the final API cost.

MiniMax H3 API Cost Calculator

Output cost
$0.40
Reference video cost
$0.00
Extra image cost
$0.00
Estimated total
$0.40

Estimated API list price

Estimate based on the current published MiniMax pay-as-you-go rates. Actual billing is determined by the API provider.

Don't want to build the API?

Don't Need an API Integration?

If you only want to generate MiniMax H3 videos without building an API integration, use the browser generator instead.

MiniMax H3 API Endpoint

MiniMax H3 uses the v2 video generation API. A generation request creates an asynchronous task and returns a task_id. Your application then queries the task endpoint until the generation succeeds and returns the video URL.

Base URL
https://api.minimax.io
Create video
POST /v2/video_generation
Query task
GET /v2/query/video_generation/{task_id}
Model
MiniMax-H3

How the MiniMax H3 API Works

  1. 1. Create

    POST /v2/video_generation

    Returns task_id

  2. 2. Poll

    GET /v2/query/video_generation/{task_id}

    Check status

  3. 3. Retrieve

    task.content.url

    Download the generated video when status is succeeded.

MiniMax H3 API cURL Example

bash
curl --request POST \
  --url https://api.minimax.io/v2/video_generation \
  --header "Authorization: Bearer $MINIMAX_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "MiniMax-H3",
    "content": [
      {
        "type": "text",
        "text": "A cinematic tracking shot of a runner crossing a rain-soaked neon street at night, synchronized footsteps and distant city ambience."
      }
    ],
    "resolution": "768P",
    "duration": 5,
    "ratio": "16:9"
  }'

A successful create request returns a task_id rather than the final video because H3 generation is asynchronous.

json
{
  "task_id": "YOUR_TASK_ID"
}
bash
curl --request GET \
  --url https://api.minimax.io/v2/query/video_generation/YOUR_TASK_ID \
  --header "Authorization: Bearer $MINIMAX_API_KEY"

When the task reaches succeeded status, the query response contains the generated video URL in task.content.url.

MiniMax H3 API Python Example

python
import os
import time
import requests

API_KEY = os.environ["MINIMAX_API_KEY"]
BASE_URL = "https://api.minimax.io"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

payload = {
    "model": "MiniMax-H3",
    "content": [
        {
            "type": "text",
            "text": (
                "A cinematic tracking shot of a runner crossing "
                "a rain-soaked neon street at night."
            ),
        }
    ],
    "resolution": "768P",
    "duration": 5,
    "ratio": "16:9",
}

create_response = requests.post(
    f"{BASE_URL}/v2/video_generation",
    headers=headers,
    json=payload,
)
create_response.raise_for_status()

task_id = create_response.json()["task_id"]
print("Task:", task_id)

while True:
    query_response = requests.get(
        f"{BASE_URL}/v2/query/video_generation/{task_id}",
        headers={"Authorization": f"Bearer {API_KEY}"},
    )
    query_response.raise_for_status()

    task = query_response.json()["task"]
    status = task["status"]

    if status == "succeeded":
        print("Video:", task["content"]["url"])
        break

    if status in {"failed", "cancelled"}:
        raise RuntimeError(f"Generation ended with status: {status}")

    time.sleep(5)

MiniMax H3 API JavaScript Example

javascript
const API_KEY = process.env.MINIMAX_API_KEY;

async function createH3Video() {
  const response = await fetch(
    "https://api.minimax.io/v2/video_generation",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        model: "MiniMax-H3",
        content: [
          {
            type: "text",
            text: "A cinematic product shot with a slow camera orbit and synchronized studio ambience.",
          },
        ],
        resolution: "768P",
        duration: 5,
        ratio: "16:9",
      }),
    }
  );

  if (!response.ok) {
    throw new Error(`MiniMax API error: ${response.status}`);
  }

  return response.json();
}

createH3Video().then(console.log);
Keep MiniMax API keys server-side. Do not expose a production API key in client-side JavaScript.

What Can You Build with the MiniMax H3 API?

Text-to-Video

Send a text prompt without media references to generate an audiovisual video from scratch.

MiniMax H3 Prompt Guide

Image-to-Video

Provide a first frame, last frame or both to control the opening and ending visual state of the generated shot.

Try Image to Video

Reference-to-Video

Combine reference images, videos and audio to control identity, motion, camera behavior, style or voice in a new generation.

Explore Reference Video

Video-Guided Generation

Use reference video to provide temporal information such as motion, performance, camera movement, cuts or timing.

Explore Video Workflows

MiniMax H3 Multimodal API Inputs

H3 uses a content array rather than separate fixed prompt and media fields. Every generation request requires a non-empty text item. Optional media entries use roles to tell H3 how each asset should influence the generation.

MiniMax H3 multimodal content types
Content typeExample rolePurpose
textRequired generation prompt
image_urlfirst_frameOpening frame
image_urllast_frameEnding frame
image_urlreference_imageIdentity/style/reference
video_urlreference_videoMotion/camera/timing reference
audio_urlreference_audioVoice/audio reference
First/last-frame mode and reference mode cannot be mixed in the same generation request.

MiniMax H3 Image-to-Video API Example

json
{
  "model": "MiniMax-H3",
  "content": [
    {
      "type": "text",
      "text": "The subject slowly turns toward the camera while the camera performs a gentle push-in."
    },
    {
      "type": "image_url",
      "image_url": {
        "url": "https://example.com/first-frame.jpg"
      },
      "role": "first_frame"
    }
  ],
  "resolution": "768P",
  "duration": 5
}

For first/last-frame image-to-video, H3 derives the aspect ratio from the supplied image, so a separate fixed ratio is not required.

MiniMax H3 Reference-to-Video API Example

Request structure example

json
{
  "model": "MiniMax-H3",
  "content": [
    {
      "type": "text",
      "text": "Use the character appearance from the image and the walking motion and camera movement from the reference video."
    },
    {
      "type": "image_url",
      "image_url": {
        "url": "https://example.com/character.jpg"
      },
      "role": "reference_image"
    },
    {
      "type": "video_url",
      "video_url": {
        "url": "https://example.com/motion-reference.mp4"
      },
      "role": "reference_video"
    }
  ],
  "resolution": "768P",
  "duration": 5,
  "ratio": "16:9"
}

MiniMax H3 API Limits

Current MiniMax H3 API limits
ParameterCurrent limit
Prompt≤ 7,000 characters
Output duration4–15 seconds
Output resolution768P / 2K
Reference imagesUp to 9
Reference videosUp to 3
Reference audioUp to 3
Mixed reference filesUp to 12 total
Reference video duration2–15 sec each; ≤15 sec total
Reference audio duration2–15 sec each; ≤15 sec total
Image size≤30 MB each
Video size≤50 MB each
Audio size≤15 MB each
Request body≤64 MB

Images: JPG, JPEG, PNG, WEBP, HEIC, HEIF

Video: MP4 / MOV using H.264/AVC or H.265/HEVC

Audio: WAV, MP3

MiniMax H3 API Aspect Ratios

MiniMax H3 API aspect ratio behavior
WorkflowRatio behavior
Text-to-videoRequired
First/last-frame I2VDetermined by input image
Reference-to-videoOptional; adaptive by default

Supported values: 21:9, 16:9, 4:3, 1:1, 3:4, 9:16, adaptive.

adaptive cannot be used as the ratio for pure text-to-video requests.

Should You Use 768P or 2K?

Choose 768P when:

  • Iterating on prompts
  • Testing application logic
  • Generating previews
  • Cost matters more than maximum output resolution

Choose 2K when:

  • Producing final deliverables
  • Detail retention matters
  • The output is intended for presentation or publishing

At current list prices, 2K costs $0.13/sec compared with $0.08/sec for 768P, so using 768P for iteration and 2K for selected final renders can reduce development costs.

MiniMax H3 768P to 2K Regeneration

MiniMax also exposes a separate regeneration workflow for converting eligible H3 768P output into 2K output. This is not a general-purpose video upscaler for arbitrary uploaded videos.

Endpoint
POST /v2/video_regeneration
Current price
$0.05 per regenerated output second

What is the MiniMax H3 API?

The MiniMax H3 API is MiniMax's pay-as-you-go video generation interface for MiniMax H3. Developers send text plus optional image, video or audio inputs to POST /v2/video_generation using the MiniMax-H3 model. The API creates an asynchronous task and returns a task_id. Current output is 4–15 second video at 768P or 2K. Last verified: August 17, 2026.

How much does the MiniMax H3 API cost?

The MiniMax H3 API currently bills video output at $0.08 per second for 768P and $0.13 per second for 2K. Reference audio is free. The first five reference images are free, then $0.04 per extra image. Reference video is billed at the same per-second rate as the selected output resolution. Last verified: August 17, 2026.

What endpoint does MiniMax H3 use?

MiniMax H3 uses POST https://api.minimax.io/v2/video_generation to create an asynchronous video generation task and GET /v2/query/video_generation/{task_id} to poll status until the video URL is available. The current model identifier is MiniMax-H3. Last verified: August 17, 2026.

Does MiniMax H3 support video input?

Yes. The MiniMax H3 API supports reference video in reference-to-video requests. Developers add a video_url item with role reference_video to supply motion, performance, camera movement, cuts or timing. Current limits are up to three reference videos, 2–15 seconds each, and 15 seconds total. Last verified: August 17, 2026.

MiniMax H3 API vs Online Generator

MiniMax H3 API compared with the MiniMax3.org generator
H3 APIMiniMax3.org Online Generator
Best forDevelopers / apps / automationCreators / quick testing
Code requiredYesNo
API key requiredYesNo provider API setup
T2VYesSupported generator workflow
Image inputYesSupported workflow
Reference inputsYesSupported in the multi-reference generator workflow
BillingProvider PAYGMiniMax3.org credits
Best useProduction integrationImmediate browser generation

Which One Should You Use?

Use the API if you are building MiniMax H3 into a product, automated pipeline or batch workflow. Use the browser generator if you want to test prompts and create H3 videos without managing authentication, polling or API integration.

Common MiniMax H3 API Errors

Common MiniMax H3 API HTTP errors
HTTPMeaningWhat to check
400Invalid parametersPrompt/content structure, resolution, duration or roles
401Authentication failedBearer API key
402Insufficient balanceAPI account balance
422Request/content rejectedSubmitted content
429Rate limitedRetry/backoff
500Server errorRetry and handle gracefully

MiniMax H3 API FAQ

Does MiniMax H3 have an API?

Yes. MiniMax H3 is available through MiniMax's pay-as-you-go API. The current video generation endpoint is POST /v2/video_generation and the model identifier is MiniMax-H3.

How much does the MiniMax H3 API cost?

Current output list pricing is $0.08 per generated second at 768P and $0.13 per generated second at 2K. Reference videos and additional reference images can add input charges.

What is the MiniMax H3 API model name?

Use MiniMax-H3 as the model value in current H3 video generation requests.

Does the MiniMax H3 API support image-to-video?

Yes. H3 supports first-frame, last-frame and first-plus-last-frame image-to-video workflows.

Can MiniMax H3 use reference videos?

Yes. Reference-to-video can use reference images, videos and audio. Video references can provide motion, performance, camera behavior, timing and other temporal information.

Does the H3 API support audio input?

Yes. Reference-to-video supports standalone audio references, and H3 generates audiovisual video with native audio.

What resolutions does the MiniMax H3 API support?

Current H3 video generation supports 768P and 2K output.

How long can a MiniMax H3 API video be?

Current output duration is 4–15 seconds using integer second values.

Is MiniMax H3 API synchronous?

No. Video generation is asynchronous. The create request returns a task_id, which your application uses to query generation status and retrieve the final video URL.

Can I try MiniMax H3 without using the API?

Yes. If you want to test H3 without building authentication, polling and API logic, you can use the MiniMax3.org browser generator. Try MiniMax H3 Online.

Primary Sources

About the author

Jaysean Brambila is the founder of MiniMax3.org, where he works on practical AI video generation workflows, prompt engineering, multimodal video tools, and creator-focused MiniMax H3 resources.

Published: August 17, 2026. Updated: August 17, 2026. Last verified: August 17, 2026.

MiniMax H3 is developed by MiniMax. MiniMax3.org is an independent third-party platform and is not affiliated with, endorsed by, or operated by MiniMax.

MiniMax3.org does not issue MiniMax API keys. Developers who need direct API access should use MiniMax's developer platform.