Name: Fast Image-to-Video Generator API (MiniMax Hailuo 2.3 Fast)
Brand: magicapi
SKU: api-magicapi-image-to-video-generator-minimax-hailuo-2-3-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Fast Image-to-Video Generator API (MiniMax Hailuo 2.3 Fast)

## Overview
The **Fast Image-to-Video Generator API (MiniMax Hailuo 2.3 Fast)** animates a still image into a short video with MiniMax's Hailuo 2.3 Fast. MiniMax describes it as a lower-latency image-to-video version of Hailuo 2.3 that keeps its core motion quality, visual consistency and stylization while allowing faster iteration. You send a first frame image and a prompt describing the motion, choose the resolution and length, and get back a URL to one MP4 video.

## Features
- **Image-to-video:** `first_frame_image` and `prompt` are both required. The output video has the same aspect ratio as the image.
- **Resolution:** `768p` (default) or `1080p`.
- **Duration:** `6` (default) or `10` seconds. 1080p supports only 6 seconds, so 10 second videos are 768p.
- **Prompt optimizer:** `prompt_optimizer` (default `true`) lets the model optimize your prompt before generation. Set it to `false` to turn this off.

## Use Cases
### Animating Product and Lifestyle Photos
Add motion and camera movement to an existing photo for ads, product pages and social posts.

### Character and Portrait Motion
Bring a character or portrait to life with a described action, such as turning, walking or gesturing.

### Fast Iteration on Shots
Try several motion prompts on the same image and keep the one that works.

### Social Stories
Use a `9:16` image as the first frame to get a vertical clip for stories and reels.

## Visual Examples
This is the real request we sent through api.market and the video it produced.

**Input image (first frame):** [View the input image](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp)

**Prompt used:**
> She pulls her hood up and walks toward the camera as the neon sign flickers in the rain

**Settings:** all other fields at their defaults (`768p`, 6 seconds, `prompt_optimizer` on).

**Output:** [Watch the example video](https://blog.api.market/wp-content/uploads/2026/10/hailuo-2.3-fast-output-api-market.mp4)

## Pricing
- **Pay As You Go (PAYG) pricing:** you only pay for what you use.
- **Price:** $0.01 per API unit.
- **Billing unit:** each request returns one video. The number of units depends on the `resolution` and `duration`:
  - **768p, 6 seconds:** 24 units = **$0.24 per video** (the default, and the example on this page)
  - **768p, 10 seconds:** 40 units = **$0.40 per video**
  - **1080p, 6 seconds:** 42 units = **$0.42 per video**
- 1080p supports only 6 second videos.
- The prompt optimizer setting does not change the price.
- **Failed or cancelled predictions** are not billed.
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation
### Base URL
```
https://prod.api.market/api/v1/magicapi/image-to-video-generator-minimax-hailuo-2-3-fast
```

### Authentication
Include your api.market API key in the `x-api-market-key` header of every request:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT:** This API is asynchronous.
1. Send `POST /predictions` with the model `version` and your `input`. A successful call returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. 201 means the prediction was accepted; it is not an error.
2. Poll `GET /predictions/{id}` every second or two.
3. Stop when `status` is `succeeded` (the `output` field holds the video URL), `failed` (see the `error` field) or `canceled`.

Video generation takes a while. The code samples below poll once per second and give up after 600 seconds (10 minutes); raise the timeout if your requests take longer.

### Endpoints

#### POST /predictions
Create a prediction. This is the request used for the example on this page:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-video-generator-minimax-hailuo-2-3-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c92f075dfd04541f1c1913a9689f778ecf76bfec3dd9fdfe19903a86e07f2cdc",
    "input": {
      "prompt": "She pulls her hood up and walks toward the camera as the neon sign flickers in the rain",
      "first_frame_image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "c92f075dfd04541f1c1913a9689f778ecf76bfec3dd9fdfe19903a86e07f2cdc",
  "status": "starting",
  "created_at": "2026-10-12T10:44:03.621Z"
}
```

#### GET /predictions/{id}
Check the status of a prediction.
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-to-video-generator-minimax-hailuo-2-3-fast/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when finished (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/hailuo-2.3-fast-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-12T10:44:03.621Z",
  "started_at": "2026-10-12T10:44:03.662Z",
  "completed_at": "2026-10-12T10:45:33.621Z"
}
```

`output` is a single URL to the generated video.

### Input Parameters
| Parameter | Type | Default | Allowed values | Required | Description |
|---|---|---|---|---|---|
| `prompt` | string | none | Any text | Yes | Text prompt for generation. |
| `first_frame_image` | string (URI) | none | Image URL | Yes | First frame image for video generation. The output video will have the same aspect ratio as this image. |
| `duration` | integer | `6` | `6`, `10` | No | Duration of the video in seconds. 10 seconds is only available for 768p resolution. |
| `resolution` | string | `768p` | `768p`, `1080p` | No | Output resolution. 1080p supports only 6-second duration. |
| `prompt_optimizer` | boolean | `true` | `true`, `false` | No | Use prompt optimizer. |

### Status Codes
- **201 Created:** Prediction created (POST). This is the normal success response.
- **200 OK:** Prediction details returned (GET).
- **400 Bad Request:** Invalid input, for example a missing `prompt` or `first_frame_image`, or 10 seconds at 1080p.
- **401 Unauthorized:** Missing or invalid API key.
- **404 Not Found:** No prediction with that ID.
- **429 Too Many Requests:** Too many requests in a short time. Wait and retry.
- **500 Internal Server Error:** Server-side error. Retry after a short wait.

### Error Handling
- A 201 response only means the prediction was accepted. Always poll until `status` is `succeeded`, `failed` or `canceled`.
- When `status` is `failed`, read the `error` field, fix the input and send a new request. Failed predictions are not billed.
- For 429 and 5xx responses, retry with exponential backoff.

## Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Implementation Guide
### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/image-to-video-generator-minimax-hailuo-2-3-fast";
const version = "c92f075dfd04541f1c1913a9689f778ecf76bfec3dd9fdfe19903a86e07f2cdc";

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function generateVideo(input) {
  const createResponse = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version, input })
  });
  if (createResponse.status !== 201 && createResponse.status !== 200) {
    throw new Error(`API error: ${createResponse.status} ${await createResponse.text()}`);
  }
  const { id } = await createResponse.json();

  const deadline = Date.now() + 10 * 60 * 1000;
  while (Date.now() < deadline) {
    const pollResponse = await fetch(`${baseUrl}/predictions/${id}`, {
      headers: { "x-api-market-key": apiKey }
    });
    if (!pollResponse.ok) {
      throw new Error(`API error: ${pollResponse.status} ${await pollResponse.text()}`);
    }
    const prediction = await pollResponse.json();
    if (prediction.status === "succeeded") return prediction.output;
    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "unknown error"}`);
    }
    await delay(1000);
  }
  throw new Error("Prediction timed out after 10 minutes");
}

generateVideo({
  "prompt": "She pulls her hood up and walks toward the camera as the neon sign flickers in the rain",
  "first_frame_image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
}).then((url) => console.log("Video:", url));
```

### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/image-to-video-generator-minimax-hailuo-2-3-fast"
VERSION = "c92f075dfd04541f1c1913a9689f778ecf76bfec3dd9fdfe19903a86e07f2cdc"

def generate_video(input_data, timeout_seconds=600):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": VERSION, "input": input_data},
    )
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    prediction_id = response.json()["id"]

    deadline = time.time() + timeout_seconds
    while time.time() < deadline:
        poll = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        poll.raise_for_status()
        prediction = poll.json()
        if prediction["status"] == "succeeded":
            return prediction["output"]
        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error')}")
        time.sleep(1)
    raise TimeoutError("Prediction timed out")

url = generate_video({
  "prompt": "She pulls her hood up and walks toward the camera as the neon sign flickers in the rain",
  "first_frame_image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
})
print("Video:", url)
```

### cURL
```bash
# Step 1: create the prediction (returns 201 with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-video-generator-minimax-hailuo-2-3-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c92f075dfd04541f1c1913a9689f778ecf76bfec3dd9fdfe19903a86e07f2cdc",
    "input": {
      "prompt": "She pulls her hood up and walks toward the camera as the neon sign flickers in the rain",
      "first_frame_image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
    }
  }'

# Step 2: poll with the id from step 1 until status is succeeded, failed or canceled
curl -X GET "https://prod.api.market/api/v1/magicapi/image-to-video-generator-minimax-hailuo-2-3-fast/predictions/PREDICTION_ID" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Tips
- Describe the motion and camera movement you want; the scene itself comes from your image.
- Pick an image with the aspect ratio you need, because the video keeps it.
- Use `768p` for drafts and 10 second clips; switch to `1080p` for 6 second final versions.

## FAQ
### Can I generate a video from text only?
No. `first_frame_image` is required for this model.

### Can I make a 10 second 1080p video?
No. 1080p supports only 6 seconds. 10 second videos are 768p (40 units, $0.40).

### What does a request cost with the defaults?
The defaults are `768p` and 6 seconds: 24 units ($0.24).

### What happens if a prediction fails?
It is not billed. Read the `error` field, fix the input and try again.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Fast image-to-video with MiniMax Hailuo 2.3 Fast from a first frame and a prompt. 6 or 10 seconds at 768p, 6 seconds at 1080p. From $0.24 per video.