# Manga AI OCR Translator (`parseforge/manga-ocr-translator`) Actor

Extract and translate text from manga images using Nano Banana AI. Processes manga panel images to extract text in multiple languages and translates to multiple target languages simultaneously. Each extracted text includes the original text and translations to all selected languages.

- **URL**: https://apify.com/parseforge/manga-ocr-translator.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 106 total users, 2 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🖼️ Manga OCR Translator

> 🚀 **Extract and translate text from manga images in minutes.** Upload manga panels, choose source and target languages, and get translated text. Supports 16 source languages and any target language. No coding, no translation accounts required.

> 🕒 **Last updated:** 2026-04-23 · **🌐 16 source languages** · **📝 OCR + translation** · **🔄 Two-step translation** · **🚫 No auth** required

The **Manga OCR Translator** reads text from manga panel images, recognizes it using OCR, and translates it to your target language. Each result returns the original text, detected language, translated text in one or more languages, and text bounding boxes. Supports 16 source languages including Japanese, Korean, Chinese, English, and more.

The Actor includes an optional two-step translation enhancer that runs the text through an LLM for more natural, context-aware manga translations.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Manga fans, translation teams, publishers, scanlation groups, localization services, accessibility tools | Manga translation, webtoon localization, OCR text extraction, multilingual publishing, fan translation |

---

### 📋 What the Manga OCR Translator does

Image-to-translation in one step:

- 🖼️ **Image input.** Upload manga panel image URLs for OCR processing.
- 🌐 **16 source languages.** Japanese, Korean, Chinese (Simplified/Traditional), English, French, German, Spanish, and more.
- 🌍 **Any target language.** Translate extracted text to one or more target languages.
- 🔄 **Translation enhancer.** Optional two-step LLM process for more natural manga translations.

Each result includes the original extracted text, detected source language, translations in each target language, and text positions within the image.

> 💡 **Why it matters:** translating manga page by page requires reading Japanese/Korean text, typing it out, and running it through translators. This Actor combines OCR and translation in a single pipeline, processing entire chapters in minutes.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from upload to translated text._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>imageUrls</td><td>array</td><td>[]</td><td>Manga image URLs to process.</td></tr>
<tr><td>originalLanguage</td><td>string</td><td>"ja"</td><td>Source language of the manga text (e.g. "ja", "ko", "zh").</td></tr>
<tr><td>targetLanguages</td><td>array</td><td>["en"]</td><td>One or more target languages for translation.</td></tr>
<tr><td>enableLingoTranslationEnhancer</td><td>boolean</td><td>false</td><td>Two-step LLM translation for more natural results.</td></tr>
</tbody>
</table>

**Example: translate Japanese manga panels to English.**

```json
{
    "imageUrls": ["https://example.com/manga-page-1.jpg", "https://example.com/manga-page-2.jpg"],
    "originalLanguage": "ja",
    "targetLanguages": ["en"]
}
````

**Example: Korean webtoon to English and Spanish with enhancer.**

```json
{
    "imageUrls": ["https://example.com/webtoon-1.jpg"],
    "originalLanguage": "ko",
    "targetLanguages": ["en", "es"],
    "enableLingoTranslationEnhancer": true
}
```

> ⚠️ **Good to Know:** OCR accuracy depends on image quality and text clarity. Clean, high-resolution scans produce the best results. Very stylized or hand-drawn text may have lower recognition accuracy.

***

### 📊 Output

Each processed image returns OCR + translation data. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ imageUrl | string | `"https://example.com/manga-page-1.jpg"` |
| 📝 originalText | string | `"こんにちは世界"` |
| 🌐 detectedLanguage | string | `"ja"` |
| 🌍 translations | object | `{ "en": "Hello world" }` |
| 📐 textBounds | array | `[{ x, y, width, height }]` |
| ⏱️ processingTimeMs | number | `2400` |
| 🕒 createdAt | ISO 8601 | `"2026-04-16T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🇯🇵 Japanese manga to English</strong></summary>

```json
{
    "imageUrl": "https://example.com/manga-page-1.jpg",
    "originalText": "こんにちは世界",
    "detectedLanguage": "ja",
    "translations": { "en": "Hello world" },
    "textBounds": [{ "x": 120, "y": 45, "width": 200, "height": 30 }],
    "processingTimeMs": 2400,
    "createdAt": "2026-04-16T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇰🇷 Korean webtoon multi-language</strong></summary>

```json
{
    "imageUrl": "https://example.com/webtoon-1.jpg",
    "originalText": "안녕하세요",
    "detectedLanguage": "ko",
    "translations": { "en": "Hello", "es": "Hola" },
    "textBounds": [{ "x": 80, "y": 100, "width": 150, "height": 25 }],
    "processingTimeMs": 3100,
    "createdAt": "2026-04-16T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>📝 Panel with no detectable text</strong></summary>

```json
{
    "imageUrl": "https://example.com/action-panel.jpg",
    "originalText": "",
    "detectedLanguage": null,
    "translations": {},
    "textBounds": [],
    "processingTimeMs": 800,
    "createdAt": "2026-04-16T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌐 | **16 source languages.** Japanese, Korean, Chinese, English, French, German, and more. |
| 🌍 | **Any target language.** Translate to one or multiple languages simultaneously. |
| 🔄 | **Translation enhancer.** Optional LLM step for natural manga-style translations. |
| 📐 | **Text positions.** Bounding box coordinates for each detected text region. |
| 📦 | **Batch processing.** Upload multiple pages and translate them all in one run. |
| ⚡ | **Fast.** Typical panels process in 2-4 seconds each. |
| 🚫 | **No accounts needed.** No translation API keys required from you. |

> 📊 The global manga market exceeds $10 billion annually, with growing demand for localized editions. Automated OCR + translation makes fan translations and professional localization faster and more accessible.

***

### 📈 How it compares to alternatives

| Approach | Cost | Languages | OCR + translate | Batch | Setup |
|---|---|---|---|---|---|
| **⭐ Manga OCR Translator** *(this Actor)* | $5 free credit, then pay-per-use | 16 source, any target | Combined | Yes | ⚡ 2 min |
| Manual OCR + Google Translate | Free | Many | Separate steps | No | 🕒 Per page |
| Paid translation services | $0.10-0.20/word | Many | Separate | Some | ⏳ Hours |
| Manga translation apps | Free-$10/month | Limited | Combined | Limited | 🕒 Variable |

Pick this Actor when you want OCR + translation in a single pipeline, with batch support and natural-language enhancement.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Manga OCR Translator page on the Apify Store.
3. 🎯 **Set input.** Upload image URLs, pick source and target languages.
4. 🚀 **Run it.** Click **Start** and let the Actor process your panels.
5. 📥 **Download.** Grab your translations in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to translated text: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📚 Translation Teams & Publishers

- Batch-translate manga chapters for localization
- Extract text for professional translator review
- Process multiple source languages in one run
- Build translation memory databases

</td>
<td width="50%" valign="top">

#### 🌐 Fan Translation & Scanlation

- Speed up fan translation workflows
- Process entire volumes in batch
- Support multi-language releases
- Combine with manga colorizer for full production

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🎓 Language Learning & Research

- Study original text alongside translations
- Build parallel text corpora from manga
- Analyze translation quality across languages
- Create language learning materials from manga

</td>
<td width="50%" valign="top">

#### ♿ Accessibility

- Extract text from image-only manga for screen readers
- Create text-based versions of visual content
- Build searchable text archives from manga
- Support assistive technology integration

</td>
</tr>
</table>

***

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Manga%20AI%20OCR%20Translator%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Manga%20AI%20OCR%20Translator%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Manga%20AI%20OCR%20Translator%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Manga%20AI%20OCR%20Translator%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

### ❓ Frequently Asked Questions

<details>
<summary><b>💳 Do I need a paid Apify plan to run this actor?</b></summary>

No. You can start right now on the free Apify plan, which includes **$5 in free monthly credit**. That is enough to run this actor several times and explore the output before committing to anything. Paid plans unlock higher limits, more concurrent runs, and larger datasets. [Create a free Apify account here](https://console.apify.com/sign-up?fpr=vmoqkp) to get started.

</details>

<details>
<summary><b>🚨 What happens if my run fails or returns no results?</b></summary>

Failed runs are not charged. If the source site changes, proxies get rate-limited, or a specific input matches nothing, re-run the actor or open our [contact form](https://tally.so/r/BzdKgA) and we will investigate. You can also check the run log in the Apify console to see why the run stopped.

</details>

<details>
<summary><b>📏 How many items can I scrape per run?</b></summary>

Free users are limited to **10 items per run** so you can preview the output and confirm the actor works for your use case. Paid users can raise maxItems up to **1,000,000** per run. [Upgrade here](https://console.apify.com/sign-up?fpr=vmoqkp) if you need full scale.

</details>

<details>
<summary><b>🕒 How fresh is the data?</b></summary>

Every run fetches live data at the moment of execution. There is no cache or delay: the records you get reflect what the source returned at that moment. Schedule the actor to maintain a rolling snapshot of the data you need.

</details>

<details>
<summary><b>🧑‍💻 Can I call this actor from my own code?</b></summary>

Yes. Apify exposes every actor as a REST endpoint and ships first-class SDKs for [Node.js](https://docs.apify.com/sdk/js) and [Python](https://docs.apify.com/sdk/python). You can start a run, read the dataset, and handle webhooks from your own app in a few lines. All you need is your Apify API token.

</details>

<details>
<summary><b>📤 How do I export the data?</b></summary>

Every Apify dataset can be downloaded in one click from the console as CSV, JSON, JSONL, Excel, HTML, XML, or RSS. You can also pull results programmatically via the [Apify API](https://docs.apify.com/api/v2) or stream them into BigQuery, S3, and other destinations through built-in integrations.

</details>

<details>
<summary><b>📅 Can I schedule the actor to run automatically?</b></summary>

Yes. Use the Apify scheduler to run the actor on any cadence, from hourly to monthly. Results are saved to your dataset and can be delivered to webhooks, email, Slack, cloud storage, or automation tools such as Zapier and Make.

***

</details>

### 🔌 Automating Manga OCR Translator

Control the translator programmatically for batch processing and pipeline integrations:

- 🟢 **Node.js.** Install the apify-client NPM package.
- 🐍 **Python.** Use the apify-client PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

### 🔌 Integrate with any app

Manga OCR Translator connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get notifications when translations are ready
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe results into your pipeline
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export translations to Drive

***

### 🔗 Recommended Actors

- [**🎨 Modern Manga Colorizer**](https://apify.com/parseforge/modern-manga-colorizer) - AI manga colorization from B\&W panels
- [**🎨 Pixel Art Generator**](https://apify.com/parseforge/pixel-art-generator) - AI pixel art from text prompts
- [**🖼️ Watermark Images**](https://apify.com/parseforge/watermark-image-api) - Batch watermarking
- [**📸 Restaurant Photo Enhancer**](https://apify.com/parseforge/restaurant-photo-enhancer) - Food photo enhancement
- [**🎬 Auto Video Thumbnail Generator**](https://apify.com/parseforge/auto-video-thumbnail-generator) - Video thumbnails

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more creative and translation tools.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new tool, propose a custom project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by any manga publisher or OCR provider. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

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

Array of manga image URLs to process. Each image will be analyzed to extract text regions. Supported formats: JPG, PNG, WebP.

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

The language of the text in the manga images. This helps OCR accuracy by using the appropriate language model.

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

Select one or more target languages for translation. The text will be translated to all selected languages.

## `enableLingoTranslationEnhancer` (type: `boolean`):

If enabled, uses a two-step translation process: first translates to English using Lingo.dev (raw translation without context), then refines and translates to multiple languages using Gemini AI (with context and Lingo translations). This can improve translation quality by providing a base translation that Gemini can refine. If disabled, only Gemini AI will be used for translation.

## Actor input object example

```json
{
  "imageUrls": [
    "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/Chapter_113_Title_Page.jpg"
  ],
  "originalLanguage": "japanese",
  "targetLanguages": [
    "english",
    "spanish"
  ],
  "enableLingoTranslationEnhancer": false
}
```

# Actor output Schema

## `overview` (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://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/Chapter_113_Title_Page.jpg"
    ],
    "originalLanguage": "japanese",
    "targetLanguages": [
        "english",
        "spanish"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/manga-ocr-translator").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://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/Chapter_113_Title_Page.jpg"],
    "originalLanguage": "japanese",
    "targetLanguages": [
        "english",
        "spanish",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/manga-ocr-translator").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://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/Chapter_113_Title_Page.jpg"
  ],
  "originalLanguage": "japanese",
  "targetLanguages": [
    "english",
    "spanish"
  ]
}' |
apify call parseforge/manga-ocr-translator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Manga AI OCR Translator",
        "description": "Extract and translate text from manga images using Nano Banana AI. Processes manga panel images to extract text in multiple languages and translates to multiple target languages simultaneously. Each extracted text includes the original text and translations to all selected languages.",
        "version": "1.0",
        "x-build-id": "SsFKE6JZ0cmDqVpkY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~manga-ocr-translator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-manga-ocr-translator",
                "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/parseforge~manga-ocr-translator/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-manga-ocr-translator",
                "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/parseforge~manga-ocr-translator/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-manga-ocr-translator",
                "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",
                    "originalLanguage",
                    "targetLanguages"
                ],
                "properties": {
                    "imageUrls": {
                        "title": "Image URLs",
                        "type": "array",
                        "description": "Array of manga image URLs to process. Each image will be analyzed to extract text regions. Supported formats: JPG, PNG, WebP."
                    },
                    "originalLanguage": {
                        "title": "Original Language",
                        "enum": [
                            "japanese",
                            "english",
                            "korean",
                            "russian",
                            "chinese",
                            "chinese-traditional",
                            "spanish",
                            "french",
                            "german",
                            "italian",
                            "portuguese",
                            "thai",
                            "vietnamese",
                            "indonesian",
                            "arabic",
                            "hindi"
                        ],
                        "type": "string",
                        "description": "The language of the text in the manga images. This helps OCR accuracy by using the appropriate language model.",
                        "default": "japanese"
                    },
                    "targetLanguages": {
                        "title": "Target Languages",
                        "type": "array",
                        "description": "Select one or more target languages for translation. The text will be translated to all selected languages.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "japanese",
                                "english",
                                "korean",
                                "russian",
                                "chinese",
                                "chinese-traditional",
                                "spanish",
                                "french",
                                "german",
                                "italian",
                                "portuguese",
                                "thai",
                                "vietnamese",
                                "indonesian",
                                "arabic",
                                "hindi"
                            ]
                        },
                        "default": [
                            "english"
                        ]
                    },
                    "enableLingoTranslationEnhancer": {
                        "title": "Enable Lingo.dev Translation Enhancer",
                        "type": "boolean",
                        "description": "If enabled, uses a two-step translation process: first translates to English using Lingo.dev (raw translation without context), then refines and translates to multiple languages using Gemini AI (with context and Lingo translations). This can improve translation quality by providing a base translation that Gemini can refine. If disabled, only Gemini AI will be used for translation.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
