Name: ToonCrafter – Animate Illustrations | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-illustration-to-animation-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎞️ Illustration-to-Animation Video API (ToonCrafter)

## Overview
The Illustration-to-Animation Video API (ToonCrafter) transforms illustrated images into seamless animated videos with minimal setup. It supports multiple input images, optional interpolation, and color correction features to deliver high-quality animations in just a few steps.

## Features
- Convert multiple illustrated images into an animated video sequence.
- Optional color correction to keep image colors consistent across frames.
- Optional interpolation for extra smooth animation.
- Flexible resolution settings, supporting up to 768×768 pixels for wide range of use cases.
- Looping capability for creating continuously repeating animations.

## Use Cases
1. • Storyboarding: Turn your storyboards into animated previews.  
2. • Artistic Demos: Illustrate concepts and show progress frames as a short, animated clip.  
3. • Marketing & Social Media: Create engaging short-form animated posts from static illustrations.  
4. • Educational Content: Demonstrate processes and concepts by transcending static slides.  
5. • Digital Comic Strips: Transform multiple comic panels into a fluid storyline.

## Visual Examples
### Example Input Illustrations
If you have multiple illustrations to combine into a single video, you can provide them as follows:

![First illustration — Example of a styled image to be animated](https://blog.api.market/wp-content/uploads/2026/04/illustration1.webp)

![Second illustration — Another frame in the sequence](https://blog.api.market/wp-content/uploads/2026/04/illustration2.webp)

![Third illustration — An optional image to include in the animation](https://blog.api.market/wp-content/uploads/2026/04/illustration3.webp)

### Example Output (Video)
Once the animation is successfully generated, you receive a link to the output video:
- 

![Generated Video using this Image to Animated AI Model](https://blog.api.market/wp-content/uploads/2026/04/illustration-output.mp4)

## Pricing
• 1 API unit = 1 image processed  
• Checking prediction status with GET /api/v1/magicapi/illustration-to-animation-api/predictions/{id} is free and does not consume API units  
• Different pricing tiers are available based on usage volume  

## API Documentation

### Base URL
All requests must be made to:  
https://prod.api.market/api/v1/magicapi/illustration-to-animation-api

### Authentication
Include your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API operates asynchronously. The typical workflow:

1. POST a new prediction to the /predictions endpoint.  
2. Receive a prediction ID.  
3. Poll the GET /predictions/{id} endpoint to check the status until it’s completed.  
4. Once status is “succeeded,” the response will contain the final video output link(s).

Implement the following best practices:  
• Poll at 1-second intervals  
• Use a maximum timeout of 600 seconds (10 minutes)  
• Continue checking status while it is "starting" or "processing"  
• Handle success when status is "succeeded"  
• Handle errors or timeouts appropriately  

### Endpoints

#### POST /predictions
Create a new prediction (i.e., request an animation).  
• Path: /api/v1/magicapi/illustration-to-animation-api/predictions  
• Method: POST  

Request Body (JSON):
- version (string) – Model version ID (use default if unsure)  
- input (object) – Your animation parameters and images  

Example:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/illustration-to-animation-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "0486ff07368e816ec3d5c69b9581e7a09b55817f567a0d74caad9395c9295c77",
    "input": {
      "prompt": "",
      "negative_prompt": "",
      "max_width": 512,
      "max_height": 512,
      "loop": false,
      "interpolate": false,
      "color_correction": true,
      "image_1": "https://example.com/image_1.jpg",
      "image_2": "https://example.com/image_2.jpg"
    }
  }'
```

Successful Response (HTTP 201):
```json
{
  "id": "prediction_id_123",
  "version": "0486ff07368e816ec3d5c69b9581e7a09b55817f567a0d74caad9395c9295c77",
  "status": "starting",
  "created_at": "2025-04-22T22:38:41.051Z"
}
```

#### GET /predictions/{id}
Fetch prediction status and (when completed) results.  
• Path: /api/v1/magicapi/illustration-to-animation-api/predictions/{id}  
• Method: GET  

Example:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/illustration-to-animation-api/predictions/prediction_id_123" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Possible Response (HTTP 200) when succeeded:
```json
{
  "id": "prediction_id_123",
  "status": "succeeded",
  "output": [
    "https://prod.api.market/outputs/tooncrafter_video_001.mp4"
  ],
  "created_at": "2025-04-22T22:38:41.051Z",
  "started_at": "2025-04-22T22:38:46.000Z",
  "completed_at": "2025-04-22T22:39:01.000Z"
}
```

## Status Codes
• 200 OK: Request processed successfully.  
• 201 Created: Prediction successfully created.  
• 400 Bad Request: There was an issue with your input parameters.  
• 401 Unauthorized: Invalid or missing API key.  
• 403 Forbidden: Valid key but insufficient permissions.  
• 404 Not Found: The requested resource (e.g., prediction ID) was not found.  
• 429 Too Many Requests: You’ve hit a rate limit. Wait before retrying.  
• 500 Internal Server Error: Our servers encountered an error. Retry later.  
• 503 Service Unavailable: Temporary downtime for maintenance or high load.  

## Rate Limits
This API enforces certain rate limits to ensure stable performance. If you hit a 429 status, reduce your request frequency or wait briefly before retrying.

## Error Handling
When an error occurs, the API will return a JSON response with details:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image_1' is required",
    "status": 400
  }
}
```
• Always check the “status” field in responses.  
• For 400–499 errors, fix your request and retry.  
• For 500–599 errors, implement a fallback or retry logic.

## Implementation Guide

### JavaScript Example
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/illustration-to-animation-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({
        version: "0486ff07368e816ec3d5c69b9581e7a09b55817f567a0d74caad9395c9295c77",
        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 with timeout
    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}`, {
      headers: { "x-magicapi-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");
}
```

### Python Example
```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/illustration-to-animation-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={
            "version": "0486ff07368e816ec3d5c69b9581e7a09b55817f567a0d74caad9395c9295c77",
            "input": input_data
        }
    )

    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 timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second

    start_time = time.time()
    headers = {"x-magicapi-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"]
        if prediction["status"] == "failed":
            raise Exception(f"Prediction failed: {prediction.get('error', 'Unknown error')}")

        time.sleep(POLL_INTERVAL)

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

### cURL Example
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/illustration-to-animation-api/predictions" \
     -H "Content-Type: application/json" \
     -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
     -d '{
         "version": "0486ff07368e816ec3d5c69b9581e7a09b55817f567a0d74caad9395c9295c77",
         "input": {
           "prompt": "A dynamic storyboard turning into a short cartoon",
           "max_width": 512,
           "max_height": 512,
           "image_1": "https://example.com/input_1.jpg",
           "image_2": "https://example.com/input_2.jpg"
         }
       }'

# Response will contain a prediction ID, e.g.:
# {"id": "prediction_id_123", "status": "starting", ...}

# Step 2: Poll the prediction status (replace prediction_id_123 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/illustration-to-animation-api/predictions/prediction_id_123" \
     -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Repeat until the "status" field is "succeeded" or "failed"
```

### Performance Optimization
- Submit images with dimensions that closely match your desired final resolution to minimize processing overhead.  
- Use fewer frames if your animation doesn’t need to be overly detailed.  
- Disable interpolation if you’re only transitioning between two images or want a quick output.

## FAQ
• How long does a typical prediction take?  
Processing time can range from a few seconds up to a couple of minutes, depending on the number of input frames and image resolution.  

• Can I create a looping animation?  
Yes, set "loop" to true in your input to seamlessly loop your output video.  

• How do I get the final video?  
Once the status is "succeeded," the output array in the GET /predictions/{id} response contains direct links to your video file.

## 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.

Turn illustrated images into smooth, animated videos in seconds. Features smooth frame interpolation. Start free on API.market.

ToonCrafter – Animate Illustrations | Free · $5/mo | API.market

🎞️ Illustration-to-Animation Video API (ToonCrafter)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Turn illustrated images into smooth, animated videos in seconds—ideal for creators seeking fast, high-quality results with ToonCrafter AI.