# Webtoons Originals Scraper (`crawlerbros/webtoons-originals-scraper`) Actor

Scrape WEBTOON Originals - browse the daily schedule, genre taxonomies, and cross-genre trending rankings, or pull full series details with episode lists. No login, no cookies, no paid proxy.

- **URL**: https://apify.com/crawlerbros/webtoons-originals-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Webtoons Originals Scraper

Scrape [WEBTOON](https://www.webtoons.com) Originals — the platform's officially published, professionally produced comics — and Canvas, its open-submission fan platform, without login, cookies, or a paid proxy. Browse the daily release schedule, genre catalogs, cross-genre trending rankings, or Canvas genre categories, or pull a single series' full metadata and episode list.

### What this actor does

- **Browse Originals by day-of-week schedule** — every daily-release bucket (Monday–Sunday) plus the Complete (finished-series) catalog, in the site's own popularity / likes / update ordering.
- **Browse Originals by genre** — all 17 official WEBTOON genre taxonomies (Action, Romance, Fantasy, Horror, Sci-fi, and more).
- **Trending / popular rankings** — the site's curated Top-30 boards: Trending (biggest movers), Popular (all-time likes), and the Originals ranking.
- **Browse Canvas by genre** — WEBTOON's open-submission fan platform, across its own 25-genre taxonomy (Romance, Comedy, LGBTQ+, Informative, and more), fully paginated.
- **Single series lookup** — full metadata (synopsis, authors, views, subscribers, schedule, genre) plus a paginated episode list (title, date, likes, thumbnail) for one series by title number or share URL. Works for both Originals and Canvas series.
- **Global** — 7 storefront locales: English, Chinese (Traditional), Thai, Indonesian, Spanish, French, German.
- **Images made public** — poster/cover/banner/episode-thumbnail images are mirrored into the dataset's Key-Value Store so every image URL resolves with no special headers; the original CDN link is kept alongside for traceability.
- **No login required.** No cookies, no API key, no paid proxy — the actor runs on the Apify free plan out of the box.
- **Empty fields are omitted** — a record only includes the fields the source page actually populates; nothing is padded with `null`, empty strings, or placeholder values.

### Modes

| Mode | What it fetches | Key inputs |
|---|---|---|
| `originals` (default) | Titles scheduled for a given day of week, or the Complete catalog | `dayOfWeek`, `sortOrder` |
| `genre` | All Originals titles in one of the 17 genre taxonomies | `genreSlug`, `sortOrder` |
| `trending` | Top-30 cross-genre ranking board | `rankingType` |
| `canvas` | All Canvas (fan-made) titles in one of 25 genre categories, or all genres | `canvasGenre`, `sortOrder` |
| `titleDetails` | One series' full profile + episode list (Originals or Canvas) | `titleNo` or `titleUrl` |

### Output

Every record includes `recordType` (`series` or `titleDetails`), `language` (resolved storefront locale), `scrapedAt` (UTC ISO timestamp), and only the fields that source page actually populates — no empty strings, nulls, or placeholder values.

#### `series` records (`originals` / `genre` / `trending` / `canvas` modes)

- `titleNo`, `title`, `genre`, `genreSlug` (Originals only — Canvas has its own, unrelated genre taxonomy)
- `canvasGenreTab` — echoes the requested Canvas genre category (mode=`canvas` only)
- `author` — creator credit (modes `genre`, `canvas` only; the daily/ranking cards don't show it)
- `likeCount` — cumulative likes shown on the browse card
- `subscriberCount` — subscriber count badge, when the site shows it (mode=`canvas` only)
- `completed` — boolean, whether the site flags the series as finished (mode=`canvas` only)
- `badge` — `NEW` or `UP` when the site flags it (Originals only)
- `matureContent` — boolean (Originals only — Canvas cards don't expose a reliable per-title rating; see FAQ)
- `scheduleDay` — echoes the requested day/complete bucket (mode=`originals`)
- `rank`, `trendDirection` (`up`/`down`), `trendDelta`, `rankingType` — ranking-board fields (mode=`trending`)
- `thumbnailUrl` / `thumbnailUrlOriginal` — poster image (mirrored / original CDN link)
- `titleUrl` — canonical series URL

#### `titleDetails` records

Works for both Originals and Canvas title numbers/URLs — the actor auto-detects and resolves whichever catalog the ID belongs to.

- `titleNo`, `seriesType` (`ORIGINALS` or `CANVAS`), `title`, `genre`, `genreSlug` (Originals only), `authors[]`, `author`
- `synopsis`
- `views`, `subscribers`
- `scheduleDay` — e.g. `EVERY MONDAY` (Originals) or `COMPLETED` (either catalog, when finished)
- `matureContent` — Originals only; Canvas detail pages don't expose this signal in static HTML (see FAQ)
- `coverUrl` / `coverUrlOriginal` — character portrait art
- `bannerUrl` / `bannerUrlOriginal` — landing-page banner art (Originals only; Canvas pages don't set one)
- `latestEpisodeNo` — highest episode number returned
- `episodes[]` — each with `episodeNo`, `title`, `date` (ISO), `likeCount`, `thumbnailUrl` / `thumbnailUrlOriginal`, `episodeUrl`
- `relatedTitles[]` — the site's own "You may also like" recommendations: `titleNo`, `title`, `author`, `views`, `thumbnailUrl` / `thumbnailUrlOriginal`, `titleUrl` (Originals only)
- `creators[]` — one entry per credited role (e.g. `Created by`, `Original work by`, `Art by`): `role`, `name`, `bio`, `socialLinks` (platform → URL, e.g. `twitter`/`instagram`/`blog`), `otherWorks[]` (that creator's other WEBTOON series: `titleNo`, `title`, `genre`, `author`, `thumbnailUrl` / `thumbnailUrlOriginal`, `titleUrl`) (Originals only)
- `titleUrl`

### Input

| Field | Type | Applies to | Description |
|---|---|---|---|
| `mode` | select | all | `originals` / `genre` / `trending` / `canvas` / `titleDetails` |
| `language` | select | all | Storefront locale: `en`, `zh-hant`, `th`, `id`, `es`, `fr`, `de` |
| `dayOfWeek` | select | `originals` | `MONDAY`…`SUNDAY`, or `COMPLETE` for finished series |
| `sortOrder` | select | `originals`, `genre`, `canvas` | `MANA` (popularity), `LIKEIT` (likes), `UPDATE` (last updated) |
| `genreSlug` | select | `genre` | One of the 17 Originals genre taxonomies (required for this mode) |
| `canvasGenre` | select | `canvas` | One of 25 Canvas genre categories, or `ALL` |
| `rankingType` | select | `trending` | `trending`, `popular`, or `originals` ranking board |
| `genreFilter` | select | `originals`, `trending` | Optionally restrict results to one Originals genre after fetching |
| `excludeMatureContent` | boolean | `originals`, `genre`, `trending` | Drop series flagged unsuitable for children (not applied to `canvas` — see FAQ) |
| `minLikeCount` | integer | `originals`, `genre`, `trending`, `canvas` | Drop series below this cumulative like count |
| `titleNo` | integer | `titleDetails` | Numeric WEBTOON title ID (from any series URL's `title_no=` param) |
| `titleUrl` | string | `titleDetails` | Full series URL — used if `titleNo` is not set |
| `includeEpisodes` | boolean | `titleDetails` | Attach the episode list to the series record |
| `maxEpisodes` | integer | `titleDetails` | Cap on episodes returned (newest first) |
| `maxItems` | integer | `originals`, `genre`, `trending`, `canvas` | Hard cap on emitted series records |
| `proxyConfiguration` | proxy | all | Optional. Not required — WEBTOON serves plain HTML with no bot challenge |

#### Example: Monday schedule, family-friendly, most-liked first

```json
{
  "mode": "originals",
  "dayOfWeek": "MONDAY",
  "sortOrder": "LIKEIT",
  "excludeMatureContent": true,
  "maxItems": 50
}
```

#### Example: all Horror titles with 100K+ likes

```json
{
  "mode": "genre",
  "genreSlug": "horror",
  "minLikeCount": 100000
}
```

#### Example: today's Top-30 trending board, Action only

```json
{
  "mode": "trending",
  "rankingType": "trending",
  "genreFilter": "action"
}
```

#### Example: full profile + last 50 episodes for one series

```json
{
  "mode": "titleDetails",
  "titleNo": 6465,
  "maxEpisodes": 50
}
```

#### Example: top-liked Canvas Romance titles

```json
{
  "mode": "canvas",
  "canvasGenre": "ROMANCE",
  "sortOrder": "LIKEIT",
  "maxItems": 50,
  "minLikeCount": 1000000
}
```

### Use cases

- **Content discovery** — build a browsable catalog of WEBTOON Originals or Canvas by genre or day
- **Market research** — track like counts, view/subscriber totals, and trending movement over time
- **Recommendation engines** — feed genre + popularity signals into a comics recommender
- **Publishing intelligence** — monitor a series' update cadence, episode release dates, and engagement
- **Localization research** — compare catalogs across the 7 supported storefront locales
- **Talent scouting** — surface rising Canvas titles by like/subscriber count before they're picked up as an Original

### FAQ

**What's the difference between `likeCount`, `views`, and `subscribers`?** `likeCount` is the cumulative-likes number shown on browse/ranking cards (heart icon). `views` and `subscribers` are separate totals only shown on a series' own detail page (`titleDetails` mode) — they measure different things and won't match `likeCount`.

**Why don't `originals`/`trending` records include an `author` field?** WEBTOON's daily-schedule and ranking cards don't display the author on the card itself — only the genre browse pages and the series detail page do. Use `mode=genre` or `mode=titleDetails` for author credits.

**Why are image URLs different from what I see on webtoons.com?** WEBTOON's image CDN blocks direct image requests that don't come from its own site (no `Referer` header = `403`). The actor fetches each image once and re-hosts it in the dataset's Key-Value Store so the URL works from anywhere, with no special headers. The original CDN link is kept in the matching `...Original` field.

**How many series can I get per genre/day?** Genre catalogs range from ~75 to ~800+ titles; each daily schedule has 130–160 titles; the Complete (finished-series) catalog has 1,000+. `maxItems` caps how many the actor emits per run, up to 1,200.

**Does this include Canvas (fan-made) comics?** Yes — use `mode=canvas` to browse WEBTOON's open-submission Canvas platform by its own 25-genre taxonomy, and `mode=titleDetails` works for Canvas title numbers/URLs too (the actor auto-detects which catalog a title belongs to). Canvas has different licensing and quality guarantees than Originals — series aren't professionally edited or officially licensed — so `seriesType` on `titleDetails` records always tells you which catalog a result came from.

**Why don't Canvas records have a `matureContent` field?** WEBTOON's Canvas listing cards render the same `unsuitableForChildren` HTML attribute as `true` on literally every card regardless of actual content, and Canvas detail pages don't embed any per-title rating data in static HTML at all. Since neither source gives a genuine signal, the actor omits `matureContent` for Canvas rather than emit a constant, meaningless value — and `excludeMatureContent` has no effect on `mode=canvas` for the same reason.

**Can I read episodes through this actor?** No — the actor deliberately stops at metadata (title, episode number, date, likes, thumbnail). It never fetches the paginated `/viewer` reader pages, consistent with WEBTOON's `robots.txt` crawl policy.

**Can I search WEBTOON by keyword?** No — WEBTOON's own `robots.txt` disallows crawling `/*/search` paths (`Disallow: /*/search`) for every crawler, so this actor intentionally does not expose a keyword-search mode. Use `genreSlug` / `canvasGenre` / `dayOfWeek` browsing together with `genreFilter` / `minLikeCount` to narrow results instead.

**Does `titleDetails` work for a title with no translation in my chosen `language`?** WEBTOON falls back to the English edition automatically when a locale translation doesn't exist. The returned `language` and `titleUrl` fields always reflect the storefront locale that was actually resolved.

**Where do `relatedTitles` and `creators` come from?** Both are scraped from the same series detail page fetched for `titleDetails` mode — no extra request is made. `relatedTitles` mirrors the "You may also like" strip WEBTOON itself shows on the page; `creators` mirrors the "author info" popup layer (name, bio, social links, and that creator's other WEBTOON series), one entry per credited role.

**Do I need a proxy?** No. WEBTOON serves plain HTML with no bot-detection challenge, so the actor runs proxy-free by default. The optional `proxyConfiguration` input is available if you ever see IP-based rate limiting on your account.

**How many series can I get per Canvas genre?** Canvas genres range from a few dozen to several thousand titles each; unlike Originals/genre listings (which return everything on one page), Canvas is paginated 20-per-page and the actor fetches as many pages as needed to satisfy `maxItems`, up to 1,200.

**Why is `likeCount` sometimes missing on a `canvas` record?** A small number of brand-new Canvas titles show a literal "Like" placeholder instead of a number on their browse card — the real count hasn't rendered server-side yet. The actor never emits a placeholder value; it simply omits `likeCount` for that record rather than guessing.

**Is this affiliated with WEBTOON?** No, this is a third-party actor using WEBTOON's publicly accessible web pages. It is not affiliated with, endorsed by, or sponsored by WEBTOON or Naver/LINE Digital Frontier.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `language` (type: `string`):

WEBTOON storefront locale to scrape.

## `dayOfWeek` (type: `string`):

Which daily-release schedule bucket to browse, or the Complete (finished series) listing.

## `genreSlug` (type: `string`):

Originals genre taxonomy to browse. Required when mode=genre.

## `canvasGenre` (type: `string`):

Canvas (fan-made / open-submission) genre category to browse. Canvas has its own genre taxonomy, distinct from Originals.

## `rankingType` (type: `string`):

Which Top-30 ranking board to fetch.

## `sortOrder` (type: `string`):

How to order the browsed list.

## `genreFilter` (type: `string`):

Optionally restrict originals/trending results to a single genre. Leave empty for no filter.

## `excludeMatureContent` (type: `boolean`):

Drop series flagged unsuitable for children (mature/graphic content). Not applied to mode=canvas — Canvas listing cards don't expose a reliable per-title content-rating flag.

## `minLikeCount` (type: `integer`):

Drop series with fewer cumulative likes than this.

## `titleNo` (type: `integer`):

Numeric WEBTOON title ID, e.g. 6465. Found in any series URL's `title_no=` query param.

## `titleUrl` (type: `string`):

Full series URL, e.g. `https://www.webtoons.com/en/fantasy/slug/list?title_no=6465`. Used if `titleNo` is not set.

## `includeEpisodes` (type: `boolean`):

Fetch and attach the episode list (numbers, dates, likes, thumbnails) for the series.

## `maxEpisodes` (type: `integer`):

Cap on episodes returned per series (newest first).

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

Hard cap on emitted series records (ignored by mode=titleDetails, which always emits 1 record). For mode=canvas, the actor paginates automatically until this cap is reached.

## `proxyConfiguration` (type: `object`):

Optional. WEBTOON serves plain HTML with no bot-challenge, so a proxy is not required. Enable only if you see request failures from your account's IP pool.

## Actor input object example

```json
{
  "mode": "originals",
  "language": "en",
  "dayOfWeek": "COMPLETE",
  "genreSlug": "romance",
  "canvasGenre": "ALL",
  "rankingType": "trending",
  "sortOrder": "UPDATE",
  "genreFilter": "",
  "excludeMatureContent": false,
  "includeEpisodes": true,
  "maxEpisodes": 30,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `series` (type: `string`):

Dataset containing all scraped WEBTOON series/episode records.

# 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 = {
    "mode": "originals",
    "language": "en",
    "dayOfWeek": "COMPLETE",
    "genreSlug": "romance",
    "canvasGenre": "ALL",
    "rankingType": "trending",
    "sortOrder": "UPDATE",
    "genreFilter": "",
    "excludeMatureContent": false,
    "includeEpisodes": true,
    "maxEpisodes": 30,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/webtoons-originals-scraper").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 = {
    "mode": "originals",
    "language": "en",
    "dayOfWeek": "COMPLETE",
    "genreSlug": "romance",
    "canvasGenre": "ALL",
    "rankingType": "trending",
    "sortOrder": "UPDATE",
    "genreFilter": "",
    "excludeMatureContent": False,
    "includeEpisodes": True,
    "maxEpisodes": 30,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/webtoons-originals-scraper").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 '{
  "mode": "originals",
  "language": "en",
  "dayOfWeek": "COMPLETE",
  "genreSlug": "romance",
  "canvasGenre": "ALL",
  "rankingType": "trending",
  "sortOrder": "UPDATE",
  "genreFilter": "",
  "excludeMatureContent": false,
  "includeEpisodes": true,
  "maxEpisodes": 30,
  "maxItems": 20
}' |
apify call crawlerbros/webtoons-originals-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/webtoons-originals-scraper"
        }
    }
}

```

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/lQxzv0DwFo6WwT9RG/builds/kliqakTS7JJqCtr2d/openapi.json