# MiniMax H3 Max API: access, pricing and code

> Is there a MiniMax H3 Max API? Call the official H3 Max API from fal on Runway Dev for fast video with sound: price, inputs and code in curl, Node, Python.

Author: Runway · Published: 2026-11-10 · Updated: 2026-11-10 · Source: https://dev.runway.com/learn/minimax-h3-max-api

## Summary

There is a MiniMax H3 Max API, and Runway Dev gives you the official MiniMax H3 Max API from fal, self-serve with an API key.\
\
MiniMax H3 Max is fal's version of MiniMax H3, built for speed: it generates video with sound from a prompt or from a first and last frame, and returns a clip in seconds.\
\
For reference images, video inputs and larger sizes, the same key calls MiniMax H3.\
\
This page covers access, pricing, inputs and code, and how your coding agent can build the integration for you.

## What is MiniMax H3 Max?

MiniMax H3 Max is a video generation model from fal, retrained from MiniMax H3 for speed. It makes clips of 5 to 15 seconds from a prompt of up to 6,000 characters, or from a first frame with an optional last frame, at 480p or 768p, and it always generates the sound of the scene in the same pass.

![A huge flock of starlings swirls in shifting shapes over a reed marsh against an orange sunset sky](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/minimax-h3-max-api-hero-starlings-396d4cbe.mp4 'One text-to-video request to MiniMax H3 Max at 768p, with its sound.')

```text
Locked-off wide shot of a huge flock of starlings swirling in shifting shapes over a reed marsh at sunset, the sky orange behind them, the reeds bending in the wind below. No people. Audio: the rush of thousands of wings and the wind in the reeds.
```

Two settings shape each request: `promptExpansionMode` decides how much the model rewrites your prompt before it generates, and a `seed` repeats a result. Short generation times make it a fit for previews, drafts and products where people wait on the clip.

## What are the ways to use MiniMax H3 Max on Runway Dev?

MiniMax H3 Max runs on Runway Dev three ways, all from one account:

| Way in                                                                                                                 | Best for                                                                                          | What you need                                                |
| ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
| [Playground](https://dev.runway.com/endpoints/text_to_video?modelId=h3_max)                                            | Trying a prompt, then copying the request as code                                                 | A Runway Dev account                                         |
| [API](https://docs.dev.runwayml.com/guides/using-the-api/) and [SDKs](https://docs.dev.runwayml.com/api-details/sdks/) | Calling MiniMax H3 Max from your own code                                                         | An API key, plus the Node or Python SDK if you want one      |
| [Coding agent](https://dev.runway.com/learn/build-with-your-coding-agent)                                                                    | Having Claude Code, Codex or Cursor build the API integration into your product, tool or pipeline | The Runway Dev MCP and skills, and an API key for live calls |

MiniMax H3 Max is also available in [Model Router](https://dev.runway.com/model-routers), a saved config you send with the request instead of a model ID. You set what to optimize for (cost, quality or latency), a maximum cost per generation and the models allowed, and the router picks one for each request sent to `POST /v1/generate/video`.

## How do you get API access to MiniMax H3 Max?

You get API access to MiniMax H3 Max with a Runway Dev account and an API key:

1. Create an account at https://dev.runway.com.
2. Create an API key in your project's dashboard.
3. Add credits to your project's balance.
4. Store the key in your environment as `RUNWAYML_API_SECRET`.
5. Send a request with `"model": "h3_max"` and the `X-Runway-Version` header to one of its endpoints. The code below is ready to run.

## How much does the MiniMax H3 Max API cost?

The MiniMax H3 Max API on Runway Dev costs 8 credits ($0.08) per second at 768p, with a lower rate at 480p. It is billed per second of output, and its frames and sound add nothing to the price.

| Resolution | Credits | USD |
| --- | --- | --- |
| 480p | 5 credits per second | $0.05 per second |
| 768p | 8 credits per second | $0.08 per second |

- Minimum 5 seconds per generation.
- A 5-second clip costs 25 credits ($0.25) at 480p or 40 credits ($0.40) at 768p.

Prices current as of November 10, 2026. 1 credit = $0.01.

![Rain makes rings on a pond between lily pads and a pink water lily as a small green frog jumps off a pad with a splash](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/minimax-h3-max-api-price-pond-d93f77b4.mp4 'MiniMax H3 Max at 768p, its largest size: 8 credits ($0.08) per second at 768p.')

```text
Locked-off close shot of a pond in summer rain: raindrops make rings across the water between round green lily pads and a pink water lily, and a small green frog on the nearest pad jumps into the water with a splash. No people. Audio: rain pattering on the water and leaves, and the plop of the frog.
```

How the billing works:

- **Output seconds are billed at the resolution's rate.** A first or last frame and the sound add nothing.
- **`resolution` sets the rate.** MiniMax H3 Max defaults to 768p, so a request that leaves it out is billed at that rate.
- **A request rejected with a 400 costs nothing.** Fields and values are checked before a task is created, so a wrong one isn't billed.
- **A task that fails input moderation (`SAFETY.INPUT.*`) is still charged.** See [task failures](https://docs.dev.runwayml.com/errors/task-failures) for what each failure means.

Every rate is also listed on [dev.runway.com/pricing](https://dev.runway.com/pricing) and in the [docs pricing guide](https://docs.dev.runwayml.com/guides/pricing/).

## What inputs does MiniMax H3 Max accept?

MiniMax H3 Max accepts a prompt of up to 6,000 characters and a duration of 5 to 15 seconds on both of its endpoints, `POST /v1/image_to_video` and `POST /v1/text_to_video`.

On `POST /v1/text_to_video` you send a `promptText`, and optionally a `resolution`, a `duration`, a `promptExpansionMode` and a `seed`. The clip is landscape.

On `POST /v1/image_to_video` the `promptImage` sets the frames. A single URL is the first frame. A list with one image whose `position` is `first`, and optionally one whose `position` is `last`, sets where the clip starts and ends. The clip takes the shape of the first frame.

![An apple tree in white spring blossom in a green meadow, a fence and hills behind it](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/minimax-h3-max-api/tree-first-c75dd0e9.jpg 'First frame') ![The same apple tree in autumn, heavy with red apples and orange leaves, the meadow gold](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/minimax-h3-max-api/tree-last-505b97e6.jpg 'Last frame')

![A time-lapse of the apple tree from spring to autumn: the blossoms fall, the leaves fill in, the apples grow and turn red as the leaves turn orange](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/minimax-h3-max-api-frames-tree-a24e504f.mp4 'The first frame and the last frame set the start and the end, and MiniMax H3 Max makes the seasons in between.')

```text
Time-lapse from a fixed viewpoint as the seasons pass over the apple tree: the white blossoms fall, the leaves fill in green, small apples grow and turn red as the leaves turn orange and the meadow turns gold. Audio: birdsong changing with the seasons and a light wind.
```

`promptExpansionMode` takes `balanced` by default for a short rewrite, `quality` for a longer one and `disabled` to keep the prompt as written. A `seed` repeats a result only with `disabled`, since the other two modes rewrite the prompt each time.

Here is every field, by endpoint:

### `POST /v1/image_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `h3_max` |
| `promptImage` (required) | One image, or a list of up to 2 images, each with a `position` of `first` or `last` (a `last` frame needs a `first` one) |
| `promptText` (required) | Text, 1 to 6,000 characters |
| `resolution` | One of `480p` or `768p` |
| `promptExpansionMode` | One of `disabled`, `balanced` or `quality` |
| `seed` | Whole number from 0 to 4,294,967,295 |
| `duration` | Whole number from 5 to 15 |

### `POST /v1/text_to_video`

| Field | Accepts |
| --- | --- |
| `model` (required) | `h3_max` |
| `promptText` (required) | Text, 1 to 6,000 characters |
| `resolution` | One of `480p` or `768p` |
| `promptExpansionMode` | One of `disabled`, `balanced` or `quality` |
| `seed` | Whole number from 0 to 4,294,967,295 |
| `duration` | Whole number from 5 to 15 |

Images go in as an HTTPS URL, a `runway://` URI from an [upload](https://docs.dev.runwayml.com/assets/uploads) or a data URI; [inputs](https://docs.dev.runwayml.com/assets/inputs) lists sizes and formats. Each table shows what a field accepts on its own. Rules that combine fields are checked when the task is submitted, and the [API reference](https://docs.dev.runwayml.com/api/) has them in full.

A few rules change what you send:

- **A `last` frame needs a `first` one.** A list with only a `last` frame returns a 400.
- **Frames have a size and shape range.** Each image is at least 256 pixels on both sides, with an aspect ratio between 1:2 and 2:1. See [inputs](https://docs.dev.runwayml.com/assets/inputs) for formats and file sizes.
- **There is no `ratio` field.** Text-to-video renders landscape, and image-to-video follows the first frame, so crop the frame to the shape you want.
- **Unknown fields return a 400.** The request schema is strict, so a field name from another API, such as `aspect_ratio` or `first_frame_image`, is rejected rather than ignored.

## How do you use the MiniMax H3 Max API?

You use the MiniMax H3 Max API by sending `h3_max` as the model to one of its endpoints. This example request, in curl, Node and Python, makes a clip with sound from text with `POST /v1/text_to_video`, and the other fields keep their defaults:

**curl**

```bash
curl -X POST https://api.dev.runwayml.com/v1/text_to_video \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "h3_max",
    "promptText": "Close shot of a small paper boat carried along a rain-filled street gutter by the running water, past fallen leaves and a stone curb, raindrops splashing on the surface. No people. Audio: rain, running water and the patter of drops on paper."
  }'

# The response carries the task id. Poll the task until it finishes:
curl https://api.dev.runwayml.com/v1/tasks/$TASK_ID \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06"
```

**Node.js**

```javascript
import RunwayML, { TaskFailedError } from '@runwayml/sdk';

// Reads your API key from RUNWAYML_API_SECRET.
const client = new RunwayML();

try {
  const task = await client.textToVideo
    .create({
      model: 'h3_max',
      promptText: 'Close shot of a small paper boat carried along a rain-filled street gutter by the running water, past fallen leaves and a stone curb, raindrops splashing on the surface. No people. Audio: rain, running water and the patter of drops on paper.',
    })
    .waitForTaskOutput();
  console.log(task.output);
} catch (error) {
  if (error instanceof TaskFailedError) {
    console.error(error.taskDetails);
  } else {
    throw error;
  }
}
```

**Python**

```python
from runwayml import RunwayML, TaskFailedError

# Reads your API key from RUNWAYML_API_SECRET.
client = RunwayML()

try:
    task = client.text_to_video.create(
        model="h3_max",
        prompt_text="Close shot of a small paper boat carried along a rain-filled street gutter by the running water, past fallen leaves and a stone curb, raindrops splashing on the surface. No people. Audio: rain, running water and the patter of drops on paper.",
    ).wait_for_task_output()
    print(task.output)
except TaskFailedError as error:
    print(error.task_details)
```

![A small paper boat is carried along a rain-filled street gutter past fallen leaves and a stone curb as raindrops splash around it](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/minimax-h3-max-api-code-paper-boat-b546da15.mp4 'The request above, as MiniMax H3 Max returns it.')

Generation is asynchronous:

- **The create request returns a task ID right away**, and the video is made in the background.
- **Poll `GET /v1/tasks/{id}` with backoff** until the status is `SUCCEEDED`, `FAILED` or `CANCELLED`. `THROTTLED` means the task is waiting in a queue, not rejected.
- **Output URLs are temporary**, so download the video when the task succeeds. See [outputs](https://docs.dev.runwayml.com/assets/outputs).
- **The SDKs poll for you.** `waitForTaskOutput()` and `wait_for_task_output()` raise `TaskFailedError` with the task's details when it fails.
- **To use your own rules instead of one fixed model**, send a [Model Router](https://dev.runway.com/learn/choosing-the-right-model)'s `configId` to `POST /v1/generate/video` in place of the model. Add `dryRun` to see which model it picks without creating a task.

## What is the difference between MiniMax H3 Max and MiniMax H3?

MiniMax H3 Max returns a clip in seconds, while [MiniMax H3](https://dev.runway.com/learn/minimax-h3-api) takes minutes and in exchange takes reference images, videos and audio, works from a clip you send and renders up to 2K. These are median generation times on Runway Dev's public API over the 30 days to November 9, 2026, without time spent in a queue:

| Clip length      | H3 Max at 480p | H3 Max at 768p | MiniMax H3 at 768p | MiniMax H3 at 2K |
| ---------------- | -------------------------- | -------------------------- | ------------------------------ | ---------------------------- |
| 5 s  | 5 s            | 8 s            | 168 s              | 267 s            |
| 10 s | 7 s            | 13 s           | 290 s              | 495 s            |
| 15 s | 9 s            | 23 s           | 373 s              | 617 s            |

Medians move with load, so treat them as a guide rather than a promise. Both clips below start from the same first frame and prompt at 768p:

![A small wooden sailboat with a red flag on its mast moored beside a stone quay in a calm harbor at golden hour](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/images/minimax-h3-api/boat-first-268941c9.jpg 'First frame')

![MiniMax H3 Max](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/minimax-h3-api-pair-boat-max-7582548f.mp4 'MiniMax H3 Max on the left and MiniMax H3 on the right, from the same first frame and prompt at 768p. Drag the divider to compare.') ![MiniMax H3](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/minimax-h3-api-pair-boat-h3-e834f911.mp4)

```text
Locked-off wide shot: small waves roll in toward the stone quay and the moored sailboat rocks gently on them, while the red flag on its mast flutters in the wind. No people. Audio: water lapping against the hull and the quay, a light wind and the creak of the mooring rope.
```

## Why does a MiniMax H3 Max API request fail?

A request to MiniMax H3 Max fails with a 400 when a field is wrong, and a task fails with a failure code that names the cause. The common ones:

- **A 400 on `promptImage`**: a `last` frame comes without a `first`, or the list holds more than two frames or a frame with no `position`.
- **A 400 on a frame's size or shape**: the image is smaller than 256 pixels on a side, or wider or taller than the 1:2 to 2:1 range. Resize or crop it.
- **A 400 on `ratio`**: MiniMax H3 Max takes no `ratio`. Remove it, and crop the first frame instead.
- **`SAFETY.INPUT.*`**: content moderation rejected an input. The task is charged and shouldn't be retried as is: change the inputs first.
- **`INTERNAL.BAD_OUTPUT.01`**: the output failed a quality check, often because of logos, watermarks or text in an input image. Remove them and retry.
- **`ASSET.INVALID`**: an input's dimensions or format are outside what the model takes. Check it against [inputs](https://docs.dev.runwayml.com/assets/inputs) and fix it before retrying.
- **`THIRD_PARTY.UNAVAILABLE`**: the model's provider didn't return the video, because of an outage or load. Wait, then retry.

## What does Runway Dev add when you call MiniMax H3 Max?

Runway Dev serves MiniMax H3 Max next to [Runway's own models and other labs' models](https://dev.runway.com/models/catalog), behind one API key and one credit balance: you build with a single key and pay a single bill, instead of an account, a key and an invoice per lab.

A coding agent can do the MiniMax H3 Max integration for you on Runway Dev, end to end. Connect the [Runway Dev MCP](https://docs.dev.runwayml.com/guides/mcp/) and the agent works from your live account: the models your project can call with their current prices and input limits, your credit balance and the record behind any task. It writes the integration against what the API accepts today, and when a task fails it looks up the reason and fixes it. The [Runway Dev skills](https://github.com/runwayml/skills) show the agent how to integrate with the official SDKs and how to build with models, Model Routers, Recipes and Workflows.

The same key calls [MiniMax H3](https://dev.runway.com/learn/minimax-h3-api) when a shot needs references, a video input or 2K, so a product can draft with H3 Max and render the final take with H3 without a second integration.

## FAQ

**Is there a MiniMax H3 Max API?**

There is a MiniMax H3 Max API, and Runway Dev serves the official H3 Max model from fal, self-serve: create an account, make an API key and send `h3_max` as the model to `POST /v1/image_to_video` and `POST /v1/text_to_video`. It runs on the same key, SDKs and credit balance as every other model on Runway Dev.

**Is the MiniMax H3 Max API on Runway Dev the official model?**

Runway Dev's MiniMax H3 Max API runs the official H3 Max model from fal. You call it with your Runway Dev API key and the model ID `h3_max`, like every other model on Runway Dev.

**Do I need a fal or MiniMax account to use the MiniMax H3 Max API?**

You don't need a fal or MiniMax account to use the MiniMax H3 Max API on Runway Dev: a Runway Dev account and API key are all you need, and H3 Max is paid from the same credit balance as every other model. To have a coding agent write the integration, connect the Runway Dev MCP and install the Runway Dev skills.

**What does MiniMax H3 Max cost per second at 480p and 768p?**

On Runway Dev, MiniMax H3 Max costs 8 credits ($0.08) per second at 768p and 5 credits ($0.05) per second at 480p. First and last frames and the sound add nothing. Prices are current as of November 10, 2026.

**How fast is MiniMax H3 Max through the API?**

MiniMax H3 Max generated a 5-second clip at 768p in a median of 8 seconds on Runway Dev's public API over the 30 days to November 9, 2026, without queue time, and a 15-second clip in 23 seconds. Times move with load.

**What is the MiniMax H3 Max model ID on Runway Dev?**

The MiniMax H3 Max model ID on Runway Dev is `h3_max`. You send it as `model` to `POST /v1/image_to_video` and `POST /v1/text_to_video`.

**Does MiniMax H3 Max generate audio through the API?**

MiniMax H3 Max always generates sound with the picture, in the same pass: the sound effects and ambient sound of the scene you describe. There is no field to turn it off, and the rate is the same either way.

**How do I get the same MiniMax H3 Max video twice?**

Send the same `seed` with `promptExpansionMode` set to `disabled`. The `balanced` and `quality` modes rewrite the prompt before each generation, so the same seed gives a different clip with them.

**Can I use MiniMax H3 Max without writing code?**

You can use MiniMax H3 Max on Runway Dev without writing code yourself. The playground sends a request from a form and gives it back as code, and a coding agent connected to the Runway Dev MCP writes the integration for you.

**Does the same Runway Dev API key work for MiniMax H3 Max and other models?**

One Runway Dev API key calls MiniMax H3 Max and every other model your project can use, Runway's own and other labs', MiniMax H3 included, with the same SDKs, task flow and credit balance. Switching models means changing the `model` field, or the rules of a Model Router.

**Why did my MiniMax H3 Max request fail with `SAFETY.INPUT.TEXT`?**

`SAFETY.INPUT.TEXT` means content moderation rejected an input of your request; the suffix hints at the prompt but may not match. The task is charged and shouldn't be retried as is, so change the prompt or inputs before you send it again.