Name: Hailuo 02 – Text to Video Generation | $0.2/call | API.market
Brand: magicapi
SKU: api-magicapi-ultra-fast-ai-text-to-video-generator
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Ultra-Fast Text-to-Video Generator API (Hailuo 02)

## Overview
The Ultra-Fast Text-to-Video Generator (Hailuo 02) is an AI-powered service designed to transform text prompts into short, high-quality videos (6s or 10s) at 512p resolution. This fast and cost-effective model is an ideal solution for rapid prototyping, quick creative explorations, and generating engaging video content with minimal overhead.

## Features
- Instant video generation from a simple text prompt at 512p resolution.
- Option to generate 6-second or 10-second videos.
- “Go Fast” mode for even shorter inference times (with slightly reduced quality).
- Prompt optimization to improve text prompt interpretations.
- Base image upload to control aspect ratio and provide a first frame.

## Use Cases
1. E-Commerce & Marketing: Quickly create short promotional videos or product teasers with minimal effort.  
2. Social Media Content Creation: Generate quick shareable clips for Instagram stories, TikTok, or Reels based on trending prompts.  
3. Education & Training: Illustrate short scenarios or demonstrations in a video format from text descriptions.  
4. Creative Prototyping: Brainstorm visual ideas and iterate rapidly before committing to full production.  
5. Advertising & Campaigns: Produce rapid prototypes for campaigns or test multiple video variations in a short time.

## Visual Examples
Below are images and videos that showcase example inputs and outputs for this API.

### Input Example
This image is used as the first frame (and aspect ratio reference) for the generated video:
![First frame example image](https://replicate.delivery/pbxt/NSrQCi9UTEoIfQbslplv9ZEAF7bNALPRqa5tQzn2nL7S3uiG/image.png)

### Output Example
A successful prediction response may include a downloadable video URL like this:
![Sample generated video output](https://blog.api.market/wp-content/uploads/2025/08/api-market-hailou.mp4)

The above examples illustrate how a prompt text such as “she looks up and grabs the front of her baseball cap as a gesture” can be turned into a short video with a chosen first frame image and specific duration.

## Pricing
- Pay As You Go (PAYG): You only pay for each call that generates a new video.
- Each 10-second video costs $0.2 / 1 unit 
- 1 unit = $0.2
- GET requests to check prediction status (GET /api/v1/magicapi/ultra-fast-ai-text-to-video-generator/predictions/{id}) are free and do not consume any API units.
- No monthly subscription fees or usage limits – simple per-call pricing.

## API Documentation

### Base URL
All API requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/ultra-fast-ai-text-to-video-generator
```

### Authentication
Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```
Replace “YOUR_API_MARKET_KEY” with your actual key.

### Asynchronous Processing
This API handles requests asynchronously. Here’s how to interact with it:
1. POST a new prediction request to create the video.  
2. Receive a prediction ID in the response.  
3. GET the status of your prediction using the ID.  
4. Continue polling until the status is “succeeded” or “failed.”

Best practices:
- Use a polling interval of 1 second between status checks.
- Your request should time out after 600 seconds (10 minutes).
- If the status is “starting” or “processing,” keep polling.
- If the status is “succeeded,” the “output” field in the response contains the video URL.
- If the status is “failed,” handle the error accordingly.

### Endpoints

#### 1. Create a Video Generation Prediction
POST /api/v1/magicapi/ultra-fast-ai-text-to-video-generator/predictions

• Creates a new video generation task.  
• Required parameters:  
  - input: JSON object containing details (prompt, first_frame_image, etc.)

Example Request:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-text-to-video-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "she looks up and grabs the front of her baseball cap as a gesture",
      "go_fast": false,
      "duration": 6,
      "prompt_optimizer": true,
      "first_frame_image": "https://replicate.delivery/pbxt/NSrQCi9UTEoIfQbslplv9ZEAF7bNALPRqa5tQzn2nL7S3uiG/image.png"
    }
  }'
```

Example Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "7acaa557f6db5f07372660faaf16007010cf9e24c365a65fee2dc01845e2f82e",
  "status": "starting",
  "created_at": "2025-08-17T16:40:50.364Z"
}
```

#### 2. Get Prediction Status
GET /api/v1/magicapi/ultra-fast-ai-text-to-video-generator/predictions/{id}

• Retrieves the status and, if complete, the output video URL for a prediction.

Example Request:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-text-to-video-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Example Response (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://replicate.delivery/xezq/iHOGUCp3MrY4Gx8xWRJeSJEoBZ74ofAcsyYqn9qM9UVgG6GVA/tmpnlecjsow.mp4",
  "error": null,
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

### Status Codes
- 200 OK: The request was successful.  
- 201 Created: A new resource (prediction) was successfully created.  
- 400 Bad Request: Invalid parameters or a malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: Valid API key but insufficient permissions.  
- 404 Not Found: The specified resource does not exist.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: A server-side error occurred.  
- 503 Service Unavailable: The service is temporarily unavailable.

### Rate Limits
When rate limits apply, requests may return 429 Too Many Requests. To handle this:
- Respect any Retry-After header if provided.  
- Implement exponential backoff to avoid flooding the service with repeated requests.

### Error Handling
The API returns a consistent JSON error format. Example:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
To handle errors:
- Check the “status” field (e.g., 400, 401, 404).
- Parse the “message” for user-friendly error handling.
- Consider retries if the issue might be transient (e.g., 503 Service Unavailable).

## Implementation Guide

### Example Code

Below are sample code snippets demonstrating how to:
1. Authenticate with the API.  
2. Submit a prediction request (POST).  
3. Poll the status endpoint (GET).  
4. Implement asynchronous logic with retries until the status becomes “succeeded” or “failed.”  

#### JavaScript (Node.js)

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-text-to-video-generator";

/**
 * Creates a new video prediction and polls until the result is ready or an error occurs.
 */
async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: POST to create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ input: inputData })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    // Step 2: Poll for results
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second  

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      method: "GET",
      headers: {
        "x-api-market-key": apiKey
      }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

// Example usage:
(async () => {
  const inputData = {
    prompt: "she looks up and grabs the front of her baseball cap as a gesture",
    go_fast: false,
    duration: 6,
    prompt_optimizer: true,
    first_frame_image: "https://replicate.delivery/pbxt/NSrQCi9UTEoIfQbslplv9ZEAF7bNALPRqa5tQzn2nL7S3uiG/image.png"
  };

  try {
    const videoUrl = await createAndWaitForPrediction(inputData);
    console.log("Generated Video URL:", videoUrl);
  } catch (error) {
    console.error("Error generating video:", error);
  }
})();
```

#### Python

```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-text-to-video-generator"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    response = requests.post(f"{BASE_URL}/predictions", json={"input": input_data}, headers=headers)
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    prediction_id = prediction["id"]

    # Step 2: Poll for results with a timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # seconds
    POLL_INTERVAL = 1  # second
    start_time = time.time()
    
    headers = {"x-api-market-key": API_KEY}
    
    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)
        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]
        elif prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")

        time.sleep(POLL_INTERVAL)

    raise Exception("Prediction timed out after 10 minutes")

# Example usage
if __name__ == "__main__":
    input_data = {
        "prompt": "she looks up and grabs the front of her baseball cap as a gesture",
        "go_fast": False,
        "duration": 6,
        "prompt_optimizer": True,
        "first_frame_image": "https://replicate.delivery/pbxt/NSrQCi9UTEoIfQbslplv9ZEAF7bNALPRqa5tQzn2nL7S3uiG/image.png"
    }

    try:
        video_url = create_and_wait_for_prediction(input_data)
        print("Generated Video URL:", video_url)
    except Exception as e:
        print("Error:", e)
```

#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-text-to-video-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "she looks up and grabs the front of her baseball cap as a gesture",
      "go_fast": false,
      "duration": 6,
      "prompt_optimizer": true,
      "first_frame_image": "https://replicate.delivery/pbxt/NSrQCi9UTEoIfQbslplv9ZEAF7bNALPRqa5tQzn2nL7S3uiG/image.png"
    }
  }'

# Example successful response:
# {
#   "id": "ufawqhfynnddngldkgtslldrkq",
#   "status": "starting"
# }

# Step 2: Poll for prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-text-to-video-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Keep polling until "status" is "succeeded" or "failed".
```

### Performance Optimization
- Use “Go Fast” mode (go_fast = true) for shorter inference times in exchange for slightly reduced video quality.  
- Optimize your prompts: Clear, descriptive text can reduce iteration and save cost.  
- Reuse first frame images if possible to maintain consistent video dimensions across multiple requests.

## FAQ
1. Q: How long does video generation typically take?  
   A: It varies based on video duration and prompt complexity. Expect a range of a few seconds to under a minute for most tasks.  
2. Q: Are partial second durations supported?  
   A: Currently, only 6s or 10s durations are supported.  
3. Q: Do I need to host my own image for the first frame?  
   A: Yes, provide a valid image URL for the initial frame.  
4. Q: Can I use any text prompt?  
   A: You can use any textual description, but keep it concise and descriptive for the best results.

## 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[at]api.market.

Generate 6s or 10s AI videos from text prompts instantly. 512p resolution with a 'Go Fast' mode. From $0.2/call. Try it free on API.market.