# AI Manga Image Colorizer (`jungle_synthesizer/ai-manga-image-colorizer`) Actor

Colorize black-and-white manga and anime panels using OpenAI GPT Image. Upload panel image URLs with your API key and receive vibrant colorized versions. Original line art and shading are preserved while scene-appropriate colors are applied.

- **URL**: https://apify.com/jungle\_synthesizer/ai-manga-image-colorizer.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** AI, For creators
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## AI Manga Image Colorizer

**Colorize black-and-white manga and anime panels using OpenAI's GPT Image model.**

Upload one or more B&W panel image URLs, provide your own OpenAI API key, and receive vibrant colorized versions. Original line art and shading are preserved while scene-appropriate, manga-style colors are applied automatically.

---

### What It Does

- Accepts a list of direct image URLs (JPG, PNG, or WebP)
- Downloads each image and submits it to the OpenAI GPT Image edit endpoint
- Returns colorized results including a hosted image URL, processing time, and status
- Handles failures gracefully — each image produces a record regardless of outcome

### Inputs

| Field | Type | Required | Description |
|---|---|---|---|
| `imageUrls` | array of strings | Yes | Direct URLs to B&W manga/anime panel images |
| `openaiApiKey` | string | Yes | Your OpenAI API key (starts with `sk-`). Get one at https://platform.openai.com/api-keys |
| `colorStyle` | string | No | Colorization style prompt. Default: `vibrant manga-style colors appropriate to the scene and characters` |
| `outputSize` | string | No | Output image size: `1024x1024` (default), `1024x1536`, `1536x1024`, or `auto` |
| `maxItems` | integer | No | Maximum number of panels to colorize. Defaults to all provided |

### Output

Each processed image produces one dataset record:

| Field | Type | Description |
|---|---|---|
| `sourceUrl` | string | Original input image URL |
| `colorizedUrl` | string | URL to the colorized image in Apify Key-Value Store |
| `style` | string | Colorization prompt used |
| `outputSize` | string | Output dimensions |
| `processingMs` | number | API round-trip time in milliseconds |
| `model` | string | OpenAI model used (`gpt-image-1`) |
| `colorizedAt` | string | ISO 8601 timestamp |
| `status` | string | `ok` or `error` |
| `errorMsg` | string | Error details when `status` is `error` |

### Requirements

- **OpenAI API key** — this actor calls the OpenAI Images Edit API. You must supply your own key. Charges apply per image processed (see [OpenAI pricing](https://openai.com/api/pricing)).
- Supported image formats: JPG, JPEG, PNG, WebP, GIF
- Maximum image size: 20 MB per file

### Example

**Input:**
```json
{
  "imageUrls": [
    "https://example.com/manga-panel-1.jpg"
  ],
  "openaiApiKey": "sk-...",
  "colorStyle": "vibrant manga-style colors appropriate to the scene and characters",
  "outputSize": "1024x1024"
}
````

**Output record (success):**

```json
{
  "sourceUrl": "https://example.com/manga-panel-1.jpg",
  "colorizedUrl": "https://api.apify.com/v2/key-value-stores/abc123/records/panel_xxx",
  "style": "vibrant manga-style colors appropriate to the scene and characters",
  "outputSize": "1024x1024",
  "processingMs": 8420,
  "model": "gpt-image-1",
  "colorizedAt": "2026-06-10T12:00:00.000Z",
  "status": "ok",
  "errorMsg": null
}
```

### Notes

- Colorized images are stored in Apify Key-Value Store (`colorized-panels`) accessible via the returned URLs during the run's data retention window.
- Up to 2 images are processed concurrently to maximize throughput while respecting OpenAI rate limits.
- Images that fail (network error, unsupported format, API error) still produce a dataset record with `status: "error"` — the run does not abort on partial failures.

# Actor input Schema

## `imageUrls` (type: `array`):

List of direct URLs to black-and-white manga/anime panel images (JPG, PNG, or WebP). Each image is colorized individually.

## `openaiApiKey` (type: `string`):

Your OpenAI API key (starts with sk-). Required to call the GPT Image API. Get one at https://platform.openai.com/api-keys.

## `colorStyle` (type: `string`):

Colorization style prompt. Default produces vibrant manga-appropriate colors. Override with a custom prompt suffix for specific palettes.

## `outputSize` (type: `string`):

Output image size. Options: 1024x1024, 1024x1536, 1536x1024, auto.

## `maxItems` (type: `integer`):

Maximum number of images to colorize. Defaults to all provided.

## Actor input object example

```json
{
  "imageUrls": [
    "https://www.w3schools.com/css/img_5terre.jpg"
  ],
  "colorStyle": "vibrant manga-style colors appropriate to the scene and characters",
  "outputSize": "1024x1024",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageUrls": [
        "https://www.w3schools.com/css/img_5terre.jpg"
    ],
    "colorStyle": "vibrant manga-style colors appropriate to the scene and characters",
    "outputSize": "1024x1024",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/ai-manga-image-colorizer").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageUrls": ["https://www.w3schools.com/css/img_5terre.jpg"],
    "colorStyle": "vibrant manga-style colors appropriate to the scene and characters",
    "outputSize": "1024x1024",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/ai-manga-image-colorizer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageUrls": [
    "https://www.w3schools.com/css/img_5terre.jpg"
  ],
  "colorStyle": "vibrant manga-style colors appropriate to the scene and characters",
  "outputSize": "1024x1024",
  "maxItems": 10
}' |
apify call jungle_synthesizer/ai-manga-image-colorizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jungle_synthesizer/ai-manga-image-colorizer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Manga Image Colorizer",
        "description": "Colorize black-and-white manga and anime panels using OpenAI GPT Image. Upload panel image URLs with your API key and receive vibrant colorized versions. Original line art and shading are preserved while scene-appropriate colors are applied.",
        "version": "0.1",
        "x-build-id": "VTG6gs4gF1HCFshQQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~ai-manga-image-colorizer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-ai-manga-image-colorizer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/jungle_synthesizer~ai-manga-image-colorizer/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-ai-manga-image-colorizer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/jungle_synthesizer~ai-manga-image-colorizer/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-ai-manga-image-colorizer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "imageUrls",
                    "openaiApiKey"
                ],
                "properties": {
                    "imageUrls": {
                        "title": "Image URLs",
                        "type": "array",
                        "description": "List of direct URLs to black-and-white manga/anime panel images (JPG, PNG, or WebP). Each image is colorized individually.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API Key",
                        "type": "string",
                        "description": "Your OpenAI API key (starts with sk-). Required to call the GPT Image API. Get one at https://platform.openai.com/api-keys."
                    },
                    "colorStyle": {
                        "title": "Colorization Style",
                        "type": "string",
                        "description": "Colorization style prompt. Default produces vibrant manga-appropriate colors. Override with a custom prompt suffix for specific palettes."
                    },
                    "outputSize": {
                        "title": "Output Size",
                        "enum": [
                            "1024x1024",
                            "1024x1536",
                            "1536x1024",
                            "auto"
                        ],
                        "type": "string",
                        "description": "Output image size. Options: 1024x1024, 1024x1536, 1536x1024, auto."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of images to colorize. Defaults to all provided."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
