# Manga Colorizer AI — Batch Comic Page Colorization (`technicaldost/manga-colorizer`) Actor

AI manga colorizer that batch-colors black-and-white manga, manhwa, and comic pages from plain image URLs. Preserves original line art, skips already-colored pages for free, upscales 2x, and delivers public URLs for every colorized page.

- **URL**: https://apify.com/technicaldost/manga-colorizer.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** AI, Automation
- **Stats:** 5 total users, 2 monthly users, 100.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Manga Colorizer AI — Batch Comic Page Colorization

**Turn black-and-white manga, manhwa, and comic pages into fully colorized images in one batch run — line art preserved, already-colored pages skipped for free, and every finished page delivered as a public URL.**

Manga Colorizer AI takes a list of publicly accessible page image URLs (JPG, PNG, or WebP), colorizes each page with AI, and stores the results in the run's key-value store with a public URL recorded in the dataset. Point it at a whole chapter and get back one clean row per page with before/after links.

### Who uses it

| User | What they get |
| --- | --- |
| Scanlation & fan-translation teams | Colorized pages ready for lettering and localization |
| Webtoon & comic publishers | Fast color passes on line-art pages before final polish |
| Content creators & social media managers | Colored manga panels for posts, thumbnails, and reels |
| AI & data pipeline builders | A batch colorization step with structured dataset output and public URLs |
| Collectors & archivists | Colorized editions of public-domain manga and woodblock pages |

### What it does

- 🎨 **AI colorization that preserves line art** — the model adds color only; every inked line, screentone, and panel border stays untouched.
- 📚 **Whole-chapter batching** — pass every page URL of a chapter in one input; the run processes them all with controlled concurrency.
- 🆓 **Free default provider** — works out of the box with a public Hugging Face colorization space, no API key required. A pluggable provider system also supports Replicate with your own token.
- 🖼️ **Style presets** — `anime`, `manga-flat`, `comic`, and `watercolor` grading, forwarded to prompt-aware providers and recorded on every row.
- 🔍 **Optional 2x upscale** — double the resolution of every output page with a high-quality Lanczos filter.
- 🗜️ **Output format choice** — save colorized pages as `png`, `webp`, or `jpg`.
- 💸 **Fair billing** — pages that already contain color are auto-detected, passed through, and **never charged**. You pay only for pages actually colorized.
- ⚙️ **Concurrency control** — tune `maxConcurrency` (default 3) to match your throughput and the backend's limits.
- 🔗 **Before/after URLs on every row** — each dataset item links the source page and the colorized result, plus status, dimensions, style, and language metadata.
- 🌐 **Language-aware metadata** — set the `originalLanguage` (Japanese, Korean, Chinese, English, other) and `targetLanguages` so downstream OCR/translation steps read text regions correctly.

### Use cases

#### Colorize a whole manga chapter

Collect the page URLs of a chapter (from your CMS, a MangaDex-style listing, or your own storage), paste them into `imageUrls`, and run. The Actor colorizes pages three at a time by default and hands you a dataset of public result URLs in the same order.

#### Pre-color line art for webtoon production

Studios use flat color passes to speed up production. Run your inked pages through the `manga-flat` preset to get a consistent base coat, then ship the public URLs straight to your artists.

#### Restore and color public-domain manga

Classics like Hokusai's manga sketchbooks are public domain but printed in monochrome. Colorize them for new editions, prints, and social content — already-colored plates are detected and skipped for free.

#### Feed a translation pipeline

Every dataset row carries `originalLanguage` and `targetLanguages`, so an OCR/translation actor can pick up the colorized pages and localize text bubbles without extra bookkeeping.

### Why choose this scraper

| Reason | Detail |
| --- | --- |
| Works with zero setup | Free Hugging Face provider needs no API key, no account, no proxy |
| Honest pricing | $0.10 per colorized page — and already-colored pages are detected and never charged |
| Batch-first design | Whole chapters in one run, with before/after URLs in every row |
| Production controls | Concurrency limit, output format, 2x upscale, style presets |
| Pluggable backend | Switch to Replicate with your own token, or point at your own Hugging Face space for guaranteed capacity |
| Structured output | Dataset rows + public key-value store URLs, ready for pipelines and integrations |

### How it compares

| | **Manga Colorizer AI (this Actor)** | parseforge / modern-manga-colorizer | muhammadafzal / manga-colorizer | jungle_synthesizer / ai-manga-image-colorizer |
| --- | --- | --- | --- | --- |
| Price per page | **$0.10** | $0.45 | Per-run compute | Per-run compute |
| Already-colored pages | Skipped, never charged | Charged | Charged | Charged |
| Free no-key mode | ✅ Built in | ❌ | ❌ | ❌ |
| Style presets | 4 presets | ❌ | ❌ | ❌ |
| 2x upscale toggle | ✅ | ❌ | ❌ | ❌ |
| Output format choice | png / webp / jpg | ❌ | ❌ | ❌ |
| Before/after URLs per row | ✅ | Partial | ❌ | ❌ |
| Concurrency control | ✅ | ❌ | ❌ | ❌ |
| Store traction (Oct 2026) | New | 705 total users, ~1 monthly active | 6 total users | 5 total users |

### Configure the run

#### Minimal: colorize a chapter with the free provider

```json
{
  "imageUrls": [
    "https://thumb.wikimedia.org/wikipedia/commons/thumb/c/c6/Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png/960px-Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png",
    "https://thumb.wikimedia.org/wikipedia/commons/thumb/f/f6/Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png/960px-Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png"
  ]
}
```

#### Full control: watercolor style, 2x upscale, WebP output, Replicate provider

```json
{
  "imageUrls": [
    "https://example.com/chapter-12/page-001.png",
    "https://example.com/chapter-12/page-002.png",
    "https://example.com/chapter-12/page-003.png"
  ],
  "originalLanguage": "korean",
  "targetLanguages": ["english", "spanish"],
  "stylePreset": "watercolor",
  "outputFormat": "webp",
  "upscale2x": true,
  "maxConcurrency": 5,
  "provider": "replicate",
  "apiToken": "YOUR_REPLICATE_TOKEN",
  "replicateModel": "cjwbw/ddcolor"
}
```

#### Input fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `imageUrls` | string array | ✅ | — | Public URLs of manga/comic pages (JPG, PNG, WebP). |
| `originalLanguage` | enum | No | `japanese` | Language of the text on the source pages. |
| `targetLanguages` | string array | No | `["english"]` | Languages you plan to localize into; stored per row. |
| `stylePreset` | enum | No | `anime` | `anime`, `manga-flat`, `comic`, or `watercolor`. |
| `outputFormat` | enum | No | `png` | `png`, `webp`, or `jpg`. |
| `upscale2x` | boolean | No | `false` | Double output resolution (Lanczos). |
| `maxConcurrency` | integer | No | `3` | Pages processed in parallel (1–10). |
| `provider` | enum | No | `huggingface-space` | Free Hugging Face space, or `replicate` with your token. |
| `hfSpaceUrl` | string | No | Public MangaColorization space | Point at your own duplicate space for guaranteed capacity. |
| `apiToken` | string | No | — | Required only for the `replicate` provider or private spaces. |
| `replicateModel` | string | No | `cjwbw/ddcolor` | Any Replicate colorization model (`owner/name`). |

### Output

Every page produces one dataset row with before/after URLs:

```json
{
  "pageNumber": 1,
  "sourceUrl": "https://example.com/chapter-12/page-001.png",
  "colorizedUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/page-0001.png",
  "status": "colorized",
  "alreadyColored": false,
  "charged": true,
  "stylePreset": "anime",
  "outputFormat": "png",
  "upscaled2x": false,
  "width": 960,
  "height": 1316,
  "provider": "huggingface-space",
  "originalLanguage": "japanese",
  "targetLanguages": ["english"],
  "meanSaturation": 0.012,
  "error": null,
  "processedAt": "2026-10-04T09:30:00.000Z"
}
```

- `status` is `colorized`, `already-colored`, or `failed`.
- The colorized image binary lives in the run's **key-value store** (`page-0001.png`, `page-0002.png`, …) and `colorizedUrl` is its public link.
- Already-colored pages are stored as-is (converted to your chosen format) with `charged: false`.
- Failed pages appear with an `error` message so one bad URL never kills a chapter run.

### Pricing

Pay per result — you are billed **only for pages actually colorized**:

| Event | Price |
| --- | --- |
| Actor start | $0.001 |
| Colorized page | **$0.10** |
| Already-colored page (auto-detected) | **$0.00 — free** |

| Pages colorized | Cost |
| --- | --- |
| 10 pages | $1.00 |
| 100 pages | $10.00 |
| 1,000 pages | $100.00 |

That is **78% cheaper per page** than parseforge/modern-manga-colorizer's $0.45 — and their actor charges even for pages that were already in color.

### Free users

On the Apify Free plan you can preview the Actor with a **10-result free run** — enough to colorize a pilot chapter and check quality before paying anything. The default provider needs no API key, so the preview works with zero setup.

### Run it

1. Open the Actor in the Apify Console and click **Try for free**.
2. Paste your page URLs into `imageUrls` (or keep the prefilled Hokusai sample pages).
3. Pick a style preset, output format, and optional 2x upscale.
4. Click **Start**, then open the **Dataset** tab for before/after links or the **Key-value store** tab to download the images.
5. Prefer code? Call it via the Apify API or the JavaScript/Python SDK with the same JSON input.

### Use with MCP (AI agents)

This Actor is MCP-ready. Add the Apify MCP server (`https://mcp.apify.com`) to Claude, Cursor, or any MCP client and ask:

> "Use the manga-colorizer Actor to colorize these 24 pages of chapter 12, anime style, webp output."

The agent passes your `imageUrls` and options as the input JSON and returns the dataset rows with public colorized URLs.

### Troubleshooting

**Q: The run failed with "The replicate provider needs an API token."**
You selected `provider: replicate` without a token. Add your Replicate API token to `apiToken`, or switch back to the default `huggingface-space` provider, which needs no key.

**Q: A page row says `failed` with an HTTP error.**
The source URL was unreachable or did not return an image. Make sure every URL is publicly accessible (open it in an incognito window) and points directly to a JPG/PNG/WebP file, not an HTML page.

**Q: The colorization timed out or returned a 503.**
The free Hugging Face space sleeps when idle and rate-limits heavy traffic. The Actor retries with backoff automatically; for guaranteed capacity, duplicate the space to your own Hugging Face account and set `hfSpaceUrl` to your copy (plus `apiToken` if private).

**Q: My sepia/aged-paper scans were colorized instead of skipped.**
That is intended — aged paper is monochrome, so the pages are treated as black-and-white and colorized. Only pages with genuinely varied colors are detected as already-colored.

**Q: Can I use my own colorization model?**
Yes. Set `provider: replicate`, add your `apiToken`, and put any `owner/name` colorization model into `replicateModel`. Your style preset is forwarded as the prompt for prompt-aware models.

### FAQ

| Question | Answer |
| --- | --- |
| Do I need an API key? | No — the default Hugging Face provider is free and keyless. |
| What image types are supported? | JPG, PNG, and WebP inputs; PNG, WebP, or JPG outputs. |
| How many pages per run? | A whole chapter — the input is an array, processed with `maxConcurrency` parallelism. |
| What counts as a chargeable result? | Only pages that were actually colorized. Already-colored pages and failed pages are never charged. |
| Does it preserve line art? | Yes — the model is trained for line-art colorization; ink lines, panel borders, and screentones are preserved. |
| Where do the images go? | The run's key-value store, with a public URL in each dataset row. |
| Can I run it from an AI agent? | Yes — via the Apify MCP server or the Apify API/SDK. |
| What languages can it read? | Set `originalLanguage` (Japanese default) and `targetLanguages`; the metadata flows through to your OCR/translation steps. |

# Actor input Schema

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

Publicly accessible URLs of black-and-white manga, manhwa, or comic pages (JPG, PNG, or WebP). Add a whole chapter to colorize it in one batch run.

## `originalLanguage` (type: `string`):

Language of the text in the source pages. Recorded with every result so downstream translation or OCR tools read the text regions correctly. The default free colorizer works on line art and is language-agnostic.

## `targetLanguages` (type: `array`):

Languages you plan to localize the colorized pages into. Stored in every dataset row so translation steps can pick the pages up automatically.

## `stylePreset` (type: `string`):

Color grading style passed to providers that accept prompts (e.g. Replicate) and recorded in every dataset row. The default Hugging Face provider auto-detects the best palette from the line art.

## `outputFormat` (type: `string`):

File format of the colorized images stored in the key-value store.

## `upscale2x` (type: `boolean`):

Double the resolution of every output page with a high-quality Lanczos filter before saving.

## `maxConcurrency` (type: `integer`):

How many pages are colorized in parallel. Lower this if the colorization backend rate-limits you.

## `provider` (type: `string`):

huggingface-space is free and needs no key (default public MangaColorization space). replicate uses your own API token and any colorization model you choose.

## `hfSpaceUrl` (type: `string`):

Base URL of a Gradio space exposing a colorization endpoint. Defaults to the free public MangaColorization space; point this at your own duplicate space for guaranteed capacity.

## `apiToken` (type: `string`):

Only needed for the replicate provider or a private Hugging Face space. Leave empty to use the free public colorizer.

## `replicateModel` (type: `string`):

Replicate colorization model in owner/name form, used only when the provider is replicate.

## Actor input object example

```json
{
  "imageUrls": [
    "https://thumb.wikimedia.org/wikipedia/commons/thumb/c/c6/Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png/960px-Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png",
    "https://thumb.wikimedia.org/wikipedia/commons/thumb/f/f6/Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png/960px-Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png"
  ],
  "originalLanguage": "japanese",
  "targetLanguages": [
    "english"
  ],
  "stylePreset": "anime",
  "outputFormat": "png",
  "upscale2x": false,
  "maxConcurrency": 3,
  "provider": "huggingface-space",
  "hfSpaceUrl": "https://1plus1-mangacolorization.hf.space",
  "replicateModel": "cjwbw/ddcolor"
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped results as dataset items (CSV, JSON, Excel, XML export).

# 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://thumb.wikimedia.org/wikipedia/commons/thumb/c/c6/Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png/960px-Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png",
        "https://thumb.wikimedia.org/wikipedia/commons/thumb/f/f6/Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png/960px-Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png"
    ],
    "targetLanguages": [
        "english"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/manga-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://thumb.wikimedia.org/wikipedia/commons/thumb/c/c6/Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png/960px-Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png",
        "https://thumb.wikimedia.org/wikipedia/commons/thumb/f/f6/Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png/960px-Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png",
    ],
    "targetLanguages": ["english"],
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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://thumb.wikimedia.org/wikipedia/commons/thumb/c/c6/Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png/960px-Archers_%28Kyujutsu%29_Page_7_by_Katsushika_Hokusai_1817.png",
    "https://thumb.wikimedia.org/wikipedia/commons/thumb/f/f6/Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png/960px-Archers_makiwara_straw_target_%28Kyujutsu%29_Page_9_by_Katsushika_Hokusai_1817.png"
  ],
  "targetLanguages": [
    "english"
  ]
}' |
apify call technicaldost/manga-colorizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,technicaldost/manga-colorizer"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HaMV0Qp9AQ3cpaVKc/builds/duKvC6KVhuKaSb3Uy/openapi.json