# MiniMax Hailuo H3 AI Video Generator (Text & Reference) (`danitn11/minimax-h3-video-generator`) Actor

AI video generator with sound: turn a text prompt — or up to 9 reference images — into a 4–8s MP4 with MiniMax Hailuo H3. 480p & 720p, 9:16 for TikTok & Reels, from $0.04/s. No GPU or subscription — a pay-as-you-go Veo, Runway & Kling alternative.

- **URL**: https://apify.com/danitn11/minimax-h3-video-generator.md
- **Developed by:** [daniel tr](https://apify.com/danitn11) (community)
- **Categories:** Developer tools, Automation, Social media
- **Stats:** 2 total users, 2 monthly users, 12.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 480p video seconds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## MiniMax Hailuo H3 AI Video Generator — Text & Reference to Video 🎬

**Generate a video with sound from a prompt, a photo, or a set of references** — powered by **MiniMax Hailuo H3**, the multimodal video model that produces native audio along with the picture. No GPU, no subscription, no monthly fees: you pay per second of finished video. A pay-as-you-go **alternative to Google Veo, Runway, Kling, and Sora**.

Perfect for **TikTok / Reels / YouTube Shorts** automation, faceless video channels, product and character ads, consistent-character series, and **n8n / Make / Zapier** workflows and AI agents.

### Three modes, no mode switch

The Actor picks the model from **what you attach** — there is nothing extra to configure:

| What you give it | Mode | What it does |
| --- | --- | --- |
| prompt only | **Text to video** | Generates the whole clip, with sound, from your prompt alone. |
| `imageUrl` (+ optional `endImageUrl`) | **First / last frame** | Animates your photo as the opening frame, and interpolates to the closing frame if you give one. |
| `referenceUrls` (1–5) | **Reference to video** | Carries the characters, products, styles, or voices from your references into a brand-new shot. |

The difference between the two image modes matters: a **first frame** is a frame the video literally starts on, while a **reference** is a subject the model recreates in a new composition. They are different models, so you pick one or the other — not both in the same run.

### Why this Actor?

- 🔊 **Sound included** — H3 generates native audio with the video: ambience, effects, and speech, from one prompt.
- 🎭 **Consistent characters & products** — attach references and the same face, outfit, or product shows up shot after shot.
- 🖼️ **Animate your own photos** — give a first frame, and optionally a last one, for controlled start-to-end motion.
- 💸 **Cheap** — from **$0.04 per second** — roughly **half MiniMax's own 768p list rate** and a fraction of what fal charges for H3. Pay only for successful videos; failed runs are never charged.
- 📐 **Social formats built in** — 9:16 (TikTok, Reels, Shorts), 16:9 (YouTube), 1:1, 21:9 cinematic, 4:3 and 3:4.
- ⏱️ **Flexible length** — any duration from 4 to 8 seconds, priced per second.
- 🔌 **Automation-ready** — call it from the Apify API, n8n, Make, Zapier, LangChain, or any AI agent via MCP.

### How it compares

| | This Actor (Hailuo H3) | Veo / Runway / Kling |
| --- | --- | --- |
| Pricing model | Pay per second of video (from $0.04/s) | Monthly subscription / credits |
| Commitment | None — pay only for what you run | Recurring plan, credits expire |
| Failed runs | Never charged | Often consume credits |
| Audio | Native, generated with the video | Varies / extra step |
| References | Up to 5 images, video, or audio (+$0.01 each) | Usually one image |
| API & automation | Native Apify API, n8n, Make, Zapier, MCP | Varies / limited |
| Watermark | None | Often on lower tiers |

### How it works

1. Write a **prompt** describing the shot — and optionally attach a **first frame image** or **reference URLs**.
2. The Actor generates the video and stores it in the run's dataset and key-value store.
3. Download the MP4 from the output, or pipe the URL into the next step of your workflow.

### Input example

Text to video:

```json
{
    "prompt": "A lone astronaut walks across a red desert at sunset, camera slowly dollies in, wind and gravel underfoot",
    "resolution": "480p",
    "aspectRatio": "9:16",
    "duration": 6
}
```

First / last frame — animate a photo:

```json
{
    "prompt": "slow push in, gentle wind, birds chirping",
    "imageUrl": "https://example.com/first.jpg",
    "endImageUrl": "https://example.com/last.jpg",
    "resolution": "480p",
    "aspectRatio": "16:9",
    "duration": 4
}
```

Reference to video:

```json
{
    "prompt": "She picks up the bottle, turns to camera and smiles, soft studio light",
    "referenceUrls": [
        "https://example.com/model.jpg",
        "https://example.com/product.png"
    ],
    "resolution": "720p",
    "aspectRatio": "9:16",
    "duration": 6,
    "cfgScale": 3.5
}
```

### Output example

```json
{
    "videoUrl": "https://api.apify.com/v2/key-value-stores/.../records/video.mp4?signature=...",
    "prompt": "A lone astronaut walks across a red desert at sunset",
    "mode": "text-to-video",
    "imageUrl": null,
    "endImageUrl": null,
    "referenceUrls": [],
    "resolution": "480p",
    "aspectRatio": "9:16",
    "duration": 6,
    "requestId": "req-...",
    "model": "minimax/minimax-h3-t2va"
}
```

### Pricing

You are charged **per second of successful video**, based on resolution — a 6-second 480p clip costs $0.24:

| Resolution | Price per second | 4s video | 6s video | 8s video |
| --- | --- | --- | --- | --- |
| 480p | $0.04 | $0.16 | $0.24 | $0.32 |
| 720p | $0.06 | $0.24 | $0.36 | $0.48 |

Choose any duration from **4 to 8 seconds**. Text-to-video and first/last-frame cost exactly this; **reference-to-video adds $0.01 per reference** (up to 5, so at most $0.05 on top). A 6s 480p clip with 3 references is $0.27. Failed generations are **never charged**.

### Tips for great results

- **Write a shot, not a caption** — subject, action, setting, then camera. Good: "a barista pulls an espresso shot, steam rising, slow push-in, warm morning light". Weak: "coffee".
- **Describe the sound you want** — H3 generates audio, so "rain on the window, distant thunder" or "upbeat crowd noise" is part of the prompt.
- **Order your references** — put the most important subject first; it anchors the shot.
- **First frame vs reference** — if the video must literally start on your image, use `imageUrl`. If you just want the same character or product in a new scene, use `referenceUrls`.
- **Describe motion, not appearance, in first/last-frame mode** — the image already defines the look, so spend the prompt on movement and camera.
- Raise **guidance scale** toward 5 to stick closer to your images, lower it toward 2 for freer motion.
- Set a **seed** to reproduce a result you liked, then vary the prompt around it.

### Use it from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/danitn11~minimax-h3-video-generator/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "prompt": "A neon-lit street at night, camera glides forward, rain and distant traffic", "duration": 6 }'
```

Works the same from the [Apify n8n node](https://apify.com/integrations), Make, Zapier, LangChain, or the Apify MCP server for AI agents.

### Templates & integrations

Drop this Actor into a no-code workflow to automate video generation end to end. In each tool, search for the **Apify** connector, authenticate with your [Apify API token](https://console.apify.com/account/integrations), and select **`danitn11/minimax-h3-video-generator`** with the action **Run Actor** (or **Run Actor and get dataset items** to receive the video URL back).

- **n8n** — add the **Apify** node → *Run Actor*, map `prompt` (and optionally `referenceUrls`) from a previous step, then push the resulting `videoUrl` to your publishing node.
- **Make.com** — use the **Apify › Run an Actor** module, then a *Get dataset items* module to read back `videoUrl`. Chain into Buffer, Google Drive, or a social uploader.
- **Zapier** — trigger (new row, form submission, etc.) → **Apify: Run Actor** → action (post to TikTok/YouTube, save to Drive, send a Slack message).

**Common pattern — automated faceless video pipeline:**

```
New prompt (Sheet / webhook / LLM step)
  → Run this Actor (prompt + optional referenceUrls)
  → Get videoUrl
  → Post to TikTok / Reels / YouTube Shorts (or save to storage)
```

### Use with AI agents (MCP server)

This Actor works as a tool for any MCP-compatible AI agent (Claude, Cursor, VS Code Copilot, custom agents) through [Apify's hosted MCP server](https://mcp.apify.com). Your agent can generate videos as part of a larger task — "make a product video and post it" — with billing through your Apify account.

**Server URL** (with this Actor preselected as a tool):

```
https://mcp.apify.com?tools=danitn11/minimax-h3-video-generator
```

Authenticate with OAuth (you'll be redirected on first connect) or an `Authorization: Bearer <APIFY_TOKEN>` header.

**Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=danitn11/minimax-h3-video-generator" -H "Authorization: Bearer <APIFY_TOKEN>"
```

**Claude Desktop / claude.ai** — add a custom connector with the server URL above (OAuth flow handles auth).

**Cursor / VS Code** — add to `.cursor/mcp.json` (or "MCP: Open User Configuration" in VS Code):

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=danitn11/minimax-h3-video-generator",
            "headers": { "Authorization": "Bearer <APIFY_TOKEN>" }
        }
    }
}
```

**Local stdio (npx)**

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": ["-y", "@apify/actors-mcp-server", "--tools", "danitn11/minimax-h3-video-generator"],
            "env": { "APIFY_TOKEN": "<APIFY_TOKEN>" }
        }
    }
}
```

Then just ask your agent: *"Generate a 6-second 9:16 video of a neon street at night, rain and traffic sounds."* The agent calls the Actor, waits for the result, and gets back the video URL from the output schema.

### FAQ

**How long does a video take to generate?**
Typically 2–5 minutes, depending on duration and resolution.

**Does the video have sound?**
Yes. H3 generates native audio together with the picture — describe the sound in your prompt.

**What can I use as a reference?**
Any publicly downloadable image, video, or audio URL — up to 5 of them.

**Can I animate my own photo?**
Yes — set `imageUrl` and it becomes the first frame. Add `endImageUrl` and the clip transitions to that final frame.

**Can I combine a first frame and references?**
No. They are separate models, so the run picks one mode; sending both is rejected before anything is charged.

**Is there a watermark?**
No. The output MP4 is clean and ready to publish.

**What model is used?**
MiniMax Hailuo H3 — `minimax-h3-t2va` for text-to-video, `minimax-h3-fl2va` for first/last frame, and `minimax-h3-ref2va` when references are attached.

# Actor input Schema

## `prompt` (type: `string`):

Describe the video you want — subject, action, setting, and camera work, e.g. "A chef plates a dish in a busy kitchen, slow dolly in, warm light". H3 also generates matching sound, so you can describe audio too: "rain on the window, distant thunder".

## `imageUrl` (type: `string`):

Animate a photo: this image becomes the first frame of the video. Leave empty for text-to-video. Cannot be combined with reference URLs — those are a different mode.

## `endImageUrl` (type: `string`):

Optional final frame — the video transitions from the first frame to this one. Only works together with a first frame image.

## `referenceUrls` (type: `array`):

Add up to 5 public URLs — images, video, or audio — to run reference-to-video: the characters, objects, styles, or voices in them are carried into a brand-new shot (not used as frames). Each reference adds $0.01 to the run. Cannot be combined with a first frame image. Each URL must be directly downloadable (no Google Drive share links or auth-gated URLs).

## `resolution` (type: `string`):

Output video resolution. 480p is fastest and cheapest; 720p is sharper. Pricing is per second and depends on resolution.

## `aspectRatio` (type: `string`):

9:16 for TikTok/Reels/Shorts, 16:9 for YouTube/landscape, 1:1 for square posts, 21:9 for cinematic, 4:3/3:4 for classic formats.

## `duration` (type: `integer`):

Length of the generated video, 4–8 seconds. You are charged per second.

## `negativePrompt` (type: `string`):

What to avoid in the video. Only applies when a first frame image or references are attached.

## `cfgScale` (type: `number`):

How closely the result follows your images and prompt, 0–5. 3.5 is a good default; higher sticks to the input more literally but can reduce motion. Only applies when a first frame image or references are attached.

## `seed` (type: `integer`):

Leave empty for a new random result each run. Set a number to reproduce the same video from the same input.

## Actor input object example

```json
{
  "prompt": "A cinematic shot of a lone astronaut walking across a red desert at sunset, camera slowly dollies in, wind and gravel underfoot",
  "referenceUrls": [],
  "resolution": "480p",
  "aspectRatio": "9:16",
  "duration": 6,
  "negativePrompt": "blur, distort, and low quality",
  "cfgScale": 3.5
}
```

# Actor output Schema

## `video` (type: `string`):

The generated video stored in the run's key-value store, ready to download or embed.

## `results` (type: `string`):

Dataset record with the video URL, prompt, mode, resolution, aspect ratio, and duration.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "prompt": "A cinematic shot of a lone astronaut walking across a red desert at sunset, camera slowly dollies in, wind and gravel underfoot"
};

// Run the Actor and wait for it to finish
const run = await client.actor("danitn11/minimax-h3-video-generator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "prompt": "A cinematic shot of a lone astronaut walking across a red desert at sunset, camera slowly dollies in, wind and gravel underfoot" }

# Run the Actor and wait for it to finish
run = client.actor("danitn11/minimax-h3-video-generator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "prompt": "A cinematic shot of a lone astronaut walking across a red desert at sunset, camera slowly dollies in, wind and gravel underfoot"
}' |
apify call danitn11/minimax-h3-video-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,danitn11/minimax-h3-video-generator"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YKfqiRhT4JBr4GN9Y/builds/lzp6jFC2CaX5f1Zk2/openapi.json