# H3 Max 3D to Video

> Transform Blender renders and 3D previs into photorealistic video. H3 Max uses the source clip to guide scene layout, camera movement, and timing, with optional image references for appearance.


## Overview

- **Endpoint**: `https://fal.run/minimax/h3-max/3d-to-video`
- **Model ID**: `minimax/h3-max/3d-to-video`
- **Category**: video-to-video
- **Kind**: inference
**Description**: Turn Blender renders and 3D previs into photorealistic video with H3 Max. Upload a source clip to guide the scene layout, camera movement, motion, and edit timing. Add optional image references to guide the look of characters, objects, and environments.

The endpoint plans the source shots, generates opening references when needed, renders each shot, and assembles the final video.

- Source video: up to 15 seconds.
- Optional reference images: up to 8.
- Output resolutions: 480P, 768P (default), and 1080P.
- Control how many new reference images may be generated (1–8; default 2).

The source video provides visual guidance; exact geometry, camera paths, and motion are not guaranteed.

**Tags**: 3d, photorealistic, previs, video-to-video



## Pricing

The first 5 seconds of video generation cost $0.75 at 480p, $0.90 at 768p, or $1.30 at 1080p per request. Additional seconds cost $0.05, $0.08, or $0.16, respectively. Input videos and reference images cost $0.02 per 1,000 tokens, with 4,096 tokens included per shot. Each generated reference image adds $0.10. Shot durations are rounded up to whole seconds, with a 5-second minimum per shot.

For more details, see [fal.ai pricing](https://fal.ai/pricing).

## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:


- **`video_url`** (`string`, _required_):
  Blender video, up to 15 seconds and 32 shots, at a public HTTPS URL.

- **`prompt`** (`string`, _optional_):
  Optional clarification of what your proxies represent or how they move, for example: 'The moving block represents a running person.' Camera, trajectories, timing and object count remain defined by the video.

- **`reference_image_urls`** (`list<string>`, _optional_):
  Optional environment, subject, interior or detail references. When supplied, uses these images directly for every shot without visual planning or generating new images; Scene Intent is optional. Without references, automatically creates appearance references within your new-image limit. Camera and movement always come from the video.
  - Array of string

- **`max_generated_reference_images`** (`integer`, _optional_):
  Maximum NEW images to generate when no reference images are supplied. Ignored when reference images are supplied. Uses fewer when enough views are covered. Uncovered shots stay in the video. Default value: `2`
  - Default: `2`
  - Range: `1` to `8`

- **`resolution`** (`QualityEnum`, _optional_):
  Output quality. Duration is taken automatically from the video. Default value: `"768P"`
  - Default: `"768P"`
  - Options: `"480P"`, `"768P"`, `"1080P"`



**Required Parameters Example**:

```json
{
  "video_url": ""
}
```

**Full Example**:

```json
{
  "video_url": "",
  "max_generated_reference_images": 2,
  "resolution": "768P"
}
```


### Output Schema

The API returns the following output format:

- **`video`** (`Video`, _required_):
  The finished realistic video, matching the input duration.



**Example Response**:

```json
{
  "video": {
    "url": "",
    "content_type": "image/png",
    "file_name": "z9RV14K95DvU.png",
    "file_size": 4404019
  }
}
```


## Usage Examples

### cURL

```bash
curl --request POST \
  --url https://fal.run/minimax/h3-max/3d-to-video \
  --header "Authorization: Key $FAL_KEY" \
  --header "Content-Type: application/json" \
  --data '{
     "video_url": ""
   }'
```

### Python

Ensure you have the Python client installed:

```bash
pip install fal-client
```

Then use the API client to make requests:

```python
import fal_client

def on_queue_update(update):
    if isinstance(update, fal_client.InProgress):
        for log in update.logs:
           print(log["message"])

result = fal_client.subscribe(
    "minimax/h3-max/3d-to-video",
    arguments={
        "video_url": ""
    },
    with_logs=True,
    on_queue_update=on_queue_update,
)
print(result)
```

### JavaScript

Ensure you have the JavaScript client installed:

```bash
npm install --save @fal-ai/client
```

Then use the API client to make requests:

```javascript
import { fal } from "@fal-ai/client";

const result = await fal.subscribe("minimax/h3-max/3d-to-video", {
  input: {
    video_url: ""
  },
  logs: true,
  onQueueUpdate: (update) => {
    if (update.status === "IN_PROGRESS") {
      update.logs.map((log) => log.message).forEach(console.log);
    }
  },
});
console.log(result.data);
console.log(result.requestId);
```


## Additional Resources

### Documentation

- [Model Playground](https://fal.ai/models/minimax/h3-max/3d-to-video)
- [API Documentation](https://fal.ai/models/minimax/h3-max/3d-to-video/api)
- [OpenAPI Schema](https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=minimax/h3-max/3d-to-video)

### fal.ai Platform

- [Platform Documentation](https://fal.ai/docs/documentation)
- [Python Client](https://fal.ai/docs/api-reference/client-libraries/python)
- [JavaScript Client](https://fal.ai/docs/api-reference/client-libraries/javascript)

### Other agent-readable surfaces

This file covers one model. To find anything else:

- [Platform overview](https://fal.ai/llms.txt): Entry points and representative endpoint IDs
- [Documentation index](https://fal.ai/docs/llms.txt): Every documentation page
- [Full documentation text](https://fal.ai/docs/llms-full.txt): The whole documentation inlined
- Any other model: `https://fal.ai/models/<endpoint-id>/llms.txt`