> ## Documentation Index
> Fetch the complete documentation index at: https://apixo.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Hailuo 2.3 Fast API: Quick Image-to-Video

> Hailuo 2.3 Fast image-to-video API with standard and pro modes for quick turnaround clips from a single reference image.

## Overview

Hailuo 2.3 Fast is an image-to-video model for turning one source image into a short generated video. Use this page when you are ready to call the API after trying the model in the APIXO playground.

| Capability | Value |
| - | - |
| Model ID | `hailuo-2-3-fast` |
| Modes | `standard-image-to-video`, `pro-image-to-video` |
| Input type | Image-to-video only |
| Reference images | Exactly 1 image URL |
| Standard duration | `6` or `10` seconds |
| Pro duration | Fixed 6 seconds |
| Output resolution | Standard: `768p`; Pro: `1080p` |
| Result type | Video URL in `resultJson.resultUrls` |

## Endpoint and authentication

Base URL:

```text theme={null}
https://api.apixo.ai/api/v1
```

| Method | Endpoint | Purpose |
| - | - | - |
| `POST` | `/generateTask/hailuo-2-3-fast` | Submit a generation task |
| `GET` | `/statusTask/hailuo-2-3-fast?taskId={taskId}` | Poll task status and retrieve results |

All requests require your APIXO API key:

```http theme={null}
Authorization: Bearer YOUR_API_KEY
```

Submit requests also require:

```http theme={null}
Content-Type: application/json
```

## Copy-paste async quickstart

This minimal request submits a standard image-to-video task and returns a `taskId`.

```bash theme={null}
curl -X POST "https://api.apixo.ai/api/v1/generateTask/hailuo-2-3-fast" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "request_type": "async",
    "input": {
      "mode": "standard-image-to-video",
      "prompt": "animate this character portrait with a gentle cinematic camera move",
      "image_urls": [
        "https://example.com/input.jpg"
      ],
      "duration": 6
    }
  }'
```

Successful response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678"
  }
}
```

Save the `taskId`; you need it to poll for the final result.

## Poll for result

```bash theme={null}
curl -X GET "https://api.apixo.ai/api/v1/statusTask/hailuo-2-3-fast?taskId=task_12345678" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

Processing response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678",
    "state": "processing",
    "createTime": 1767965610929
  }
}
```

Success response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678",
    "state": "success",
    "resultJson": "{\"resultUrls\":[\"https://file.apixo.ai/video.mp4\"]}",
    "createTime": 1767965610929,
    "completeTime": 1767965730929,
    "costTime": 120000
  }
}
```

Failed response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678",
    "state": "failed",
    "failCode": "SensitiveContent",
    "failMsg": "Content violates provider policy, please adjust the prompt",
    "createTime": 1767965610929,
    "completeTime": 1767965620132
  }
}
```

Parse `resultJson` after `state` becomes `success`:

```javascript theme={null}
const payload = JSON.parse(data.resultJson);
const videoUrls = payload.resultUrls;
```

## Request body

### Standard image-to-video

```json theme={null}
{
  "request_type": "async",
  "input": {
    "mode": "standard-image-to-video",
    "prompt": "animate this still image with smooth parallax and lighting changes",
    "image_urls": [
      "https://example.com/input.jpg"
    ],
    "duration": 10
  }
}
```

### Pro image-to-video

```json theme={null}
{
  "request_type": "async",
  "input": {
    "mode": "pro-image-to-video",
    "prompt": "animate this image into a high-energy camera move",
    "image_urls": [
      "https://example.com/input.jpg"
    ]
  }
}
```

## Parameters

<ParamField body="request_type" type="string" required default="async">
  Result delivery mode. Use `async` for polling with `statusTask`, or `callback` for webhook delivery.
</ParamField>

<ParamField body="callback_url" type="string">
  Required when `request_type` is `callback`. Must be a public HTTPS URL that can receive the final task payload. See [Webhooks](/docs/api-reference/webhooks).
</ParamField>

<ParamField body="input" type="object" required>
  Hailuo 2.3 Fast input parameters.

  <Expandable title="properties">
    <ParamField body="mode" type="string" required>
      Generation mode. Supported values: `standard-image-to-video`, `pro-image-to-video`. Use the exact lowercase value; text-to-video modes are not supported.
    </ParamField>

    <ParamField body="prompt" type="string" required>
      Text prompt describing the desired motion and scene. Must be a non-empty string and no more than 2,000 UTF-8 bytes; whitespace-only prompts are rejected. Maximum length: 2000 UTF-8 bytes.
    </ParamField>

    <ParamField body="image_urls" type="string[]" required>
      Source image URLs. Must contain exactly one non-empty string. The image should be a public JPG, JPEG, or PNG URL, no larger than 20 MB, with an aspect ratio greater than 2:5 and less than 5:2, and a short side greater than 300 px.
    </ParamField>

    <ParamField body="duration" type="integer|string">
      Required for `standard-image-to-video`. Supported values: `6`, `10`, `"6"`, or `"10"`. The backend normalizes valid values to an integer for generation and billing. Ignored for `pro-image-to-video`, which always outputs a 6-second video.
    </ParamField>
  </Expandable>
</ParamField>

<Tip>
  Hailuo 2.3 Fast only supports image-to-video. If you need text-to-video, use a different Hailuo model that explicitly supports that mode.
</Tip>

## Response format

### Submit task response

`POST /generateTask/hailuo-2-3-fast` returns a task ID when the task is accepted:

<ResponseField name="code" type="integer">
  API status code. `200` means the task was accepted.
</ResponseField>

<ResponseField name="message" type="string">
  Human-readable status message.
</ResponseField>

<ResponseField name="data.taskId" type="string">
  Unique task identifier used with the status endpoint.
</ResponseField>

### Status response fields

<ResponseField name="taskId" type="string">
  Unique task identifier.
</ResponseField>

<ResponseField name="state" type="string">
  Current task state: `processing`, `success`, or `failed`.
</ResponseField>

<ResponseField name="resultJson" type="string">
  JSON string containing the generated video URLs. Present when `state` is `success`.
</ResponseField>

<ResponseField name="failCode" type="string">
  Machine-readable failure code. Present when `state` is `failed`.
</ResponseField>

<ResponseField name="failMsg" type="string">
  Human-readable failure message. Present when `state` is `failed`.
</ResponseField>

<ResponseField name="createTime" type="integer">
  Task creation timestamp in Unix milliseconds.
</ResponseField>

<ResponseField name="completeTime" type="integer">
  Task completion timestamp in Unix milliseconds. Present after completion when available.
</ResponseField>

<ResponseField name="costTime" type="integer">
  Processing duration in milliseconds. Present after completion when available.
</ResponseField>

## Webhook callback mode

Use callback mode when your backend should receive the final result automatically instead of polling.

```bash theme={null}
curl -X POST "https://api.apixo.ai/api/v1/generateTask/hailuo-2-3-fast" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "request_type": "callback",
    "callback_url": "https://your-server.com/webhooks/apixo",
    "input": {
      "mode": "pro-image-to-video",
      "prompt": "animate this product photo with a polished studio camera move",
      "image_urls": [
        "https://example.com/input.jpg"
      ]
    }
  }'
```

See [Webhooks](/docs/api-reference/webhooks) for delivery requirements and retry behavior.

## Billing

Hailuo 2.3 Fast billing depends on the selected `mode`. Standard mode is billed by output duration; pro mode is billed per task.

| Mode | Unit | APIXO price | Billable amount |
| - | - | - | - |
| `standard-image-to-video` | Per output second | `$0.032 / second` | `duration * $0.032` |
| `pro-image-to-video` | Per task | `$0.33 / use` | `$0.33` |

For current route and market comparison pricing, see [Pricing](https://apixo.ai/pricing).

## Latency and polling

Video generation is asynchronous. Actual latency may vary by input image, prompt complexity, current queue load, and storage transfer time.

| Mode | Output duration | Recommended first poll | Poll interval |
| - | - | - | - |
| `standard-image-to-video` | `6` or `10` seconds | 30s after task creation | 10s |
| `pro-image-to-video` | Fixed 6 seconds | 30s after task creation | 10s |

`costTime` is returned in milliseconds after completion when timing data is available. Keep polling while `state` is `processing`.

<Tip>
  For production workloads, use callback mode to avoid frequent polling on long-running video tasks.
</Tip>

Rate limits and concurrency can vary by account, API key, and route. If you receive `429`, slow down requests and retry with backoff. For account-level details, see [System APIs](/docs/api-reference/system).

## Errors and troubleshooting

### HTTP errors

| Code | Meaning | What to do |
| - | - | - |
| `400` | Invalid request body, missing required field, unsupported mode, invalid duration, or invalid input URL | Fix the request before retrying |
| `401` | Missing or invalid API key | Check the `Authorization` header |
| `402` | Insufficient balance or quota | Add balance or switch account/key |
| `403` | Key or route cannot access the model | Check permissions and route strategy |
| `429` | Rate limit or concurrency limit reached | Retry with exponential backoff |
| `500` | Server error or unmapped upstream failure | Retry with backoff |
| `502` | Upstream provider error | Retry with backoff |
| `504` | Upstream timeout | Retry or use callback mode for long-running jobs |

### Task failure codes

Failure codes are mapped from upstream task errors, so exact values can vary. Common examples include:

| Fail code | Meaning | What to do |
| - | - | - |
| `PromptInvalid` | Prompt was invalid or rejected | Rewrite the prompt and retry |
| `SensitiveContent` | Prompt or media violated provider policy | Change the prompt or input image |
| `NSFW` | Input or output was flagged as NSFW | Use different content |
| `ProhibitedContentDetected` | Prohibited content was detected | Change the prompt or input image |
| `ImageFormatIncorrect` | Image format or upload validation failed | Use a public JPG, JPEG, or PNG URL |
| `InvalidImageSize` | Image dimensions or size were invalid | Check aspect ratio, short side, and file size |
| `RateLimited` | Upstream provider rate limit was reached | Retry with exponential backoff |
| `Timeout` | Upstream provider timed out | Retry, simplify the prompt, or use callback mode |
| `InsufficientBalance` | Provider-side balance or quota was insufficient | Retry later or contact support |
| `Unknown error` | Upstream failure was not mapped to a known code | Retry with backoff; contact support if it persists |

### Request checks

* Send exactly one `image_urls` item.
* Use only `standard-image-to-video` or `pro-image-to-video`.
* Include `duration` only when you need standard mode; pro mode ignores it.
* Use `duration` as `6`, `10`, `"6"`, or `"10"` for standard mode.
* Use a public, directly fetchable JPG, JPEG, or PNG image URL.

See [Error Codes](/docs/api-reference/errors) for the full error reference.

## Related links

* [Generation API Overview](/docs/models)
* [Video Models](/docs/models/video)
* [Generate Task](/docs/api-reference/generate-task)
* [Status Task](/docs/api-reference/status-task)
* [Webhooks](/docs/api-reference/webhooks)
* [Error Codes](/docs/api-reference/errors)
* [Parameter Specification](/docs/api-reference/parameters)
* [Routing Strategies](/docs/concepts/routing-strategies)
* [Try Hailuo 2.3 Fast in the APIXO Playground](https://apixo.ai/models/hailuo-2-3-fast)
* [Pricing](https://apixo.ai/pricing)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.