Name: Toonify Flux – Photo to Cartoon | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-cartoon-image-generator
Availability: InStock
Rating: 5.00 (3 reviews)
Author: API Market

Shashank Agarwal

# 🎨 Cartoon Image Generator API (Flux) - High-Quality Instant Results

## Overview
The Cartoon Image Generator API transforms any photo into a cartoon-style image almost instantly. By leveraging advanced rendering methods, it creates vivid, high-quality outputs suitable for profile avatars, social media posts, marketing campaigns, and creative storytelling. The model handles various image formats and offers flexible aspect ratios, making it easy to integrate into diverse workflows.

## Features
- Converts images to a detailed cartoon style with vibrant colors and sharp outlines.
- High-resolution output supporting multiple formats (JPG or PNG).
- Configurable aspect ratios, or automatically match the source image’s dimensions.
- Seed-based randomization option for reproducible results.
- Reliable and scalable asynchronous API—submit a job and poll for status.

## Use Cases
1. Social Media & Entertainment: Enhance profile pictures with cartoon avatars to stand out and increase engagement.  
2. E-commerce & Branding: Turn product photos into eye-catching cartoon versions for marketing campaigns.  
3. Digital Art & Comics: Rapidly create stylized characters from real photography for comic strips or illustrated stories.  
4. Gaming & Virtual Worlds: Generate in-game cartoon portraits or user icons from real-life images.  
5. Education & Creative Storytelling: Automatically convert educational illustrations and diagrams for fun presentations or e-learning content.

## Visual Examples

Below are example images showcasing input and output:

### Example Input
![Example of the original photo (Mona Lisa) that will be converted into a cartoon](https://blog.api.market/wp-content/uploads/2026/04/mona-lisa-api-market.jpg)

### Example Output
![Example of the resulting cartoon-style image](https://blog.api.market/wp-content/uploads/2026/04/mona-lisa-cartoon.png)

These examples demonstrate how the service can transform a classic portrait into a playful, cartoon-like illustration.

## Pricing
- 1 API unit = 1 image processed.  
- GET requests to check prediction status (GET /api/v1/magicapi/cartoon-image-generator/predictions/{id}) are free and do not count toward usage.  
- Various pricing tiers are available based on your monthly volume. Contact us for customized plans.

## API Documentation

### Base URL
All API requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/cartoon-image-generator
```

### Authentication
Include your API key in the request header:  
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
Make sure to keep your API key secure and do not expose it on the client side of public applications.

### Asynchronous Processing
This API processes cartoon transformations asynchronously:

1. POST your cartoon conversion request.  
2. The API responds immediately with a unique prediction ID.  
3. Poll the GET endpoint using the prediction ID to retrieve status.  
4. Continue polling until the status is "succeeded" or "failed".  

Typical polling interval is 1 second, and the maximum timeout is 600 seconds (10 minutes).

### Endpoints

#### 1) Create a Prediction
• Method: POST  
• Endpoint: /api/v1/magicapi/cartoon-image-generator/predictions  

Use this to submit a new image for cartoon conversion.

Request Body (JSON):
```json
{
  "version": "1caa4fcfc16f1962ff4f6c821f0a0ce7bb941d2e010a002328b2cdff7edc5924",
  "input": {
    "input_image": "https://some-domain.com/your-image.jpg",
    "aspect_ratio": "match_input_image",
    "seed": 1,
    "output_format": "png",
    "safety_tolerance": 2
  }
}
```

Response (201 - Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "1caa4fcfc16f1962ff4f6c821f0a0ce7bb941d2e010a002328b2cdff7edc5924",
  "status": "starting",
  "created_at": "2025-06-05T20:18:32.269Z"
}
```

Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/cartoon-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "1caa4fcfc16f1962ff4f6c821f0a0ce7bb941d2e010a002328b2cdff7edc5924",
    "input": {
      "input_image": "https://some-domain.com/your-image.jpg",
      "aspect_ratio": "match_input_image",
      "seed": 1,
      "output_format": "png",
      "safety_tolerance": 2
    }
  }'
```

#### 2) Get Prediction Status and Results
• Method: GET  
• Endpoint: /api/v1/magicapi/cartoon-image-generator/predictions/{id}

Use this endpoint to retrieve the status of a prediction and, if complete, the final cartoon image URL.

Response (200 - OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://domain.com/path-to-your-cartoon-image.png",
  "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"
}
```

Example cURL:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/cartoon-image-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

## Status Codes
- 200 OK: Request succeeded.  
- 201 Created: Resource successfully created (e.g., new prediction).  
- 400 Bad Request: Invalid input parameters or malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: Valid API key but insufficient permissions to access the resource.  
- 404 Not Found: The requested resource (prediction) was not found.  
- 429 Too Many Requests: Rate limit exceeded—wait before retrying.  
- 500 Internal Server Error: Server encountered an unexpected error.  
- 503 Service Unavailable: Server is temporarily unable to handle requests.

## Rate Limits
We enforce rate limits to ensure fair usage. If you exceed the current rate limit, you will receive a 429 status code. You should implement backoff and retry logic when encountering 429 responses.

## Error Handling
If an error occurs, the service returns a JSON response with an "error" property:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'input_image' is required",
    "status": 400
  }
}
```
You can handle these errors by inspecting the HTTP status code and the "message" field to determine what went wrong.

## Implementation Guide

Below are end-to-end examples showing how to create a prediction, poll for status, and handle errors. Note that the key steps are:
1. POST a new prediction.  
2. Get the prediction ID from the response.  
3. Poll the GET /predictions/{id} endpoint every second until completion or a 10-minute timeout.  
4. If the status is "succeeded," retrieve the cartoon image URL from the "output" field.  
5. If "failed," record or handle the error.

### Example Code

```javascript
// JavaScript example with proper polling and timeout

const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/cartoon-image-generator";

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: "1caa4fcfc16f1962ff4f6c821f0a0ce7bb941d2e010a002328b2cdff7edc5924",
        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; // 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
# 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/cartoon-image-generator"

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

    if not response.ok:
        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  # 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 not response.ok:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if 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")
```

```bash
# cURL example

# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/cartoon-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "1caa4fcfc16f1962ff4f6c821f0a0ce7bb941d2e010a002328b2cdff7edc5924",
    "input": {
      "input_image": "https://some-domain.com/myphoto.jpg"
    }
  }'

# Step 2: Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/cartoon-image-generator/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Use the smallest possible input image size that still meets your quality needs to reduce processing time.  
- Implement caching for repeated requests of the same image.  
- Poll for results with a 1-second interval; avoid hammering the API with overly frequent requests.  

## FAQ
1. **What image formats are supported?**  
   JPG, PNG, GIF, and WebP are supported for input.  

2. **How large can the input image be?**  
   There is no strict file size limit in these docs, but very large images may take longer to process.  

3. **Do I pay for status checks?**  
   No. GET requests to check a prediction’s status are free.  

4. **How long should I wait before considering a request failed?**  
   Set a maximum timeout of 10 minutes for polling.  

5. **Can I retrieve results after an extended period?**  
   Yes, you can query the GET endpoint anytime, though it’s good practice to download and store your result.  

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

Instantly transform photos into vivid, high-quality cartoons. From $0.05/call. Try it free on API.market.

Toonify Flux – Photo to Cartoon | $0.05/call | API.market