# Naver Webtoon Scraper — Rankings & Catalog (Korea's #1) (`kdatafactory/naver-webtoon-scraper`) Actor

Scrape Naver Webtoon (comic.naver.com), Korea's #1 webtoon platform. Weekday lineup & completed catalog as clean JSON: title, author, weekday, user rating, new/hiatus/completed flags, thumbnail, URL — plus total views on the completed catalog. For IP scouting, trend tracking, fan tools & AI agents.

- **URL**: https://apify.com/kdatafactory/naver-webtoon-scraper.md
- **Developed by:** [Seok June Park](https://apify.com/kdatafactory) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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

## Naver Webtoon Scraper 🇰🇷📚

Scrape [Naver Webtoon](https://comic.naver.com) (네이버 웹툰) — **Korea's #1 webtoon
platform** and the birthplace of global hits like *Lookism*, *Tower of God* and
*True Beauty*. Get the **weekday lineup rankings** and the **completed-series catalog**
as clean, structured JSON (title, author, weekday, user star rating, new/hiatus/completed
flags, thumbnail, URL — plus cumulative view counts on the completed catalog), exportable
to JSON, CSV, or Excel.

Webtoons are Korea's fastest IP pipeline: today's top-rated weekday title is tomorrow's
Netflix drama or feature film. This actor gives you that catalog as data.

> **Try it free.** Apify's free plan includes $5 of monthly platform credit — roughly **2,000 results** from this actor, no credit card required. Set your input, click Start, and export JSON/CSV/Excel.

---

### 🚀 What it does

Give it a **mode** and it returns a structured webtoon catalog:

| Mode | What you get | Example input |
|------|--------------|---------------|
| `weekday` | The **current weekly lineup** — every ongoing title on the Mon–Sun tabs (or a single tab), ranked in your chosen order | `{ "mode": "weekday" }` |
| `completed` | The **finished-series catalog** (~3,000 completed titles), paginated — with full cumulative view counts when sorted by views | `{ "mode": "completed", "order": "view" }` |

Choose a **weekday** (`all`, `mon`…`sun`, or the `dailyPlus` daily-webtoon tab), a
**sort order** (`user` rating, `view` count, `update` recency) and how many titles to
pull (`maxItems`).

---

### 📥 Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `weekday` | `weekday` (weekly lineup) or `completed` (finished-series catalog). |
| `week` | string | `all` | Weekday tab: `all` (Mon–Sun in one request), `mon`…`sun`, or `dailyPlus` (매일+ daily webtoons). Weekday mode only. |
| `order` | string | `user` | `user` (star rating), `view` (cumulative views), `update` (latest update). |
| `maxItems` | integer | `200` | Max titles to return. Full weekly lineup ≈ 780 rows; completed catalog ≈ 3,000 titles. |
| `proxyConfiguration` | object | off | Optional Apify proxy. Not required — the API is datacenter friendly; enable for IP diversity at scale. |

**Input example — the full weekly lineup, top-rated first:**

```json
{
  "mode": "weekday",
  "week": "all",
  "order": "user",
  "maxItems": 800
}
````

***

### 📤 Output

Each webtoon is one dataset record in this shape (real samples from live runs):

```json
{
  "source": "naver_webtoon",
  "title_id": "758037",
  "title": "참교육",
  "author": "채용택 / 한가람",
  "weekday": "mon",
  "rank": 1,
  "rating": 9.9,
  "view_count": null,
  "is_new": false,
  "is_rest": false,
  "is_up": false,
  "is_adult": false,
  "is_completed": false,
  "url": "https://comic.naver.com/webtoon/list?titleId=758037",
  "thumbnail_url": "https://image-comic.pstatic.net/webtoon/758037/thumbnail/thumbnail_IMAG21_6323d62f-2b2d-4668-9373-156f16487568.jpg",
  "scraped_at": "2026-07-10T15:21:02.382+09:00"
}
```

A `completed` + `order: "view"` record additionally carries the lifetime view count:

```json
{
  "source": "naver_webtoon",
  "title_id": "325629",
  "title": "패션왕",
  "author": "기안84",
  "weekday": null,
  "rank": 2,
  "rating": 8.34,
  "view_count": 366878225,
  "is_completed": true,
  "url": "https://comic.naver.com/webtoon/list?titleId=325629"
}
```

**Field notes**

- `author` — the **public pen-name credit** shown on every webtoon card (writer / artist /
  original author, e.g. `채용택 / 한가람`). This is commercial authorship attribution, like
  an artist name on an album — no personal profiles, IDs, or contact details are collected.
- `weekday` — `mon`…`sun` or `dailyPlus` for the lineup; `null` for the completed catalog.
  A title serialized on several days appears once per day (that *is* the lineup).
- `rank` — 1-based position in the chosen ordering, per weekday tab (weekday mode) or
  across the catalog (completed mode).
- `rating` — user star rating, 0–10 scale (e.g. `9.9`).
- `view_count` — lifetime views. **Fully populated only in `completed` mode with
  `order: "view"`**; elsewhere the API hides the number for most titles and the field is
  `null` (see Known limitations).
- `is_new` / `is_rest` / `is_up` — new series, on hiatus (휴재), episode updated.
- `is_adult` — age-restricted (19+) flag; `is_completed` — series has ended.
- A 40-record real sample (both modes) lives in
  [`samples/sample-output.json`](samples/sample-output.json).

***

### 💡 Use cases

- **Webtoon IP & adaptation scouting** — webtoons are the source material for Korea's
  drama/film pipeline. Rank the lineup by user rating or views and spot adaptation
  candidates before they are optioned.
- **Content market research** — track lineup composition by weekday, new-series inflow
  (`is_new`), hiatus rates (`is_rest`), and completed-catalog performance over time.
- **Trend tracking** — schedule daily runs and diff the rankings: rising titles, rating
  moves, lineup entries and exits.
- **Fan tooling** — build update notifiers, reading lists, or catalog browsers on clean
  JSON instead of scraping HTML.
- **AI agents & LLM pipelines** — feed a structured catalog of Korea's #1 webtoon platform
  into RAG or a content-analysis assistant.

***

### 🌐 Data source

This actor reads Naver Webtoon's **public** titlelist API on `comic.naver.com` — the same
JSON endpoints the site's own weekday tabs and completed-catalog pages call. No login, no
private API, no HTML parsing. The API is datacenter friendly, so **no proxy is required**;
you can enable an Apify proxy for IP diversity when running at scale.

***

### ⚠️ Known limitations (honest notes)

- **`view_count` is only fully populated in `completed` mode with `order: "view"`.** The
  weekday endpoint sorts by views but exposes the actual number for only a couple of
  titles per weekday — all hidden values are emitted as `null`, never fake zeros.
- **The completed catalog can include a few long-hiatus titles.** Naver lists some
  indefinitely-paused series in its finished tab; they come through with
  `is_completed: false` / `is_rest: true`, exactly as the API flags them.
- **No genre or synopsis fields.** The titlelist API does not return genre labels or
  descriptions, so they are not advertised here. Per-episode data and reader comments are
  out of scope (comments are personal data and are never collected).

***

### ⚖️ Rate & legality note

- Only **public, non-personal** catalog data is collected — the same lineup anyone sees on
  comic.naver.com without logging in. **No personal data**: no reader comments, nicknames,
  or profiles (the actor never calls comment endpoints), and the API's internal author-id /
  personal-blog sub-fields are deliberately dropped. `author` is the public pen-name
  credit, like an artist name on an album.
- Requests are **rate-limited** (sequential requests, ≥500 ms delay) to stay light on the
  site — a full weekly lineup is a single API call.
- You are responsible for complying with Naver's Terms of Service and applicable law in
  your jurisdiction. Use the data for research, monitoring, and analytics — not to
  replicate the platform or redistribute the comics themselves.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal catalog data — the same weekday lineup and completed list any visitor sees on Naver Webtoon without logging in. No reader data or personal information is collected. You are responsible for how you use the data; see the rate & legality note above.

**What does it cost in practice?**
$2.50 per 1,000 results (launch pricing) + a few cents of platform usage. Example: the full weekly lineup (~780 rows) costs about $1.95 per snapshot. Apify's free $5 monthly credit covers ~2,000 results.

**Do I need to configure proxies?**
No — the default settings work out of the box. Optionally, enable an Apify proxy for IP diversity when running at scale.

**How fresh is the data?**
Every run scrapes the live Naver Webtoon API at run time. Schedule the actor daily to build a rankings time series.

**What is NOT included?**
Reader comments and any reader/user data (never collected), genre/synopsis (not exposed by the titlelist API), per-episode lists, and `view_count` outside `completed` + `order: "view"` (emitted as `null`, see Known limitations).

***

### 🇰🇷 More Korean data actors

This actor is part of a suite of Korean-platform scrapers by the same maintainer:

- [ktown4u-scraper](https://apify.com/kdatafactory/ktown4u-scraper) — K-pop albums & goods from the global fan commerce leader.
- [pocamarket-scraper](https://apify.com/kdatafactory/pocamarket-scraper) — K-pop photocard marketplace listings & prices.
- [tumblbug-scraper](https://apify.com/kdatafactory/tumblbug-scraper) — Korea's creative crowdfunding platform, project & funding data.

Browse all: [apify.com/kdatafactory](https://apify.com/kdatafactory)

***

### 🏃 Run it

On Apify: set your input and click **Start**. Locally:

```bash
npm install
## put your input in storage/key_value_stores/default/INPUT.json
npm start
```

Results land in the default dataset (Apify) or `./storage/datasets/default` (local).

***

*If this actor saves you time, a rating on the [Store page](https://apify.com/kdatafactory/naver-webtoon-scraper) helps a solo maintainer a lot. Found an issue? Open it in the Issues tab — I respond fast.*

# Actor input Schema

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

'weekday' = the current weekly lineup (the site's weekday tabs). 'completed' = the finished-series catalog (~3,000 titles, paginated).

## `week` (type: `string`):

Weekday tab to scrape (weekday mode only). 'all' pulls every tab Mon–Sun in a single request; 'dailyPlus' is the 매일+ (Daily+) tab of daily webtoons.

## `order` (type: `string`):

Result ordering. 'user' = user star rating, 'view' = cumulative views, 'update' = latest update. Note: view\_count fully populates only in completed mode with order 'view'; the weekday lineup sorts by views but exposes the count for only a few titles.

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

Maximum number of webtoons to return. The full weekly lineup is ~780 rows (one per weekday slot); the completed catalog is ~3,000 titles (paginated at 45 per request).

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

Optional Apify proxy. The titlelist API is not IP-blocked (datacenter friendly), so a proxy is not required; enable one for IP diversity at scale.

## Actor input object example

```json
{
  "mode": "weekday",
  "week": "all",
  "order": "user",
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": "weekday",
    "week": "all",
    "order": "user",
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("kdatafactory/naver-webtoon-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": "weekday",
    "week": "all",
    "order": "user",
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("kdatafactory/naver-webtoon-scraper").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 '{
  "mode": "weekday",
  "week": "all",
  "order": "user",
  "maxItems": 200
}' |
apify call kdatafactory/naver-webtoon-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kdatafactory/naver-webtoon-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Webtoon Scraper — Rankings & Catalog (Korea's #1)",
        "description": "Scrape Naver Webtoon (comic.naver.com), Korea's #1 webtoon platform. Weekday lineup & completed catalog as clean JSON: title, author, weekday, user rating, new/hiatus/completed flags, thumbnail, URL — plus total views on the completed catalog. For IP scouting, trend tracking, fan tools & AI agents.",
        "version": "0.1",
        "x-build-id": "lpH1K9lPtK3UegP6u"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kdatafactory~naver-webtoon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kdatafactory-naver-webtoon-scraper",
                "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/kdatafactory~naver-webtoon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kdatafactory-naver-webtoon-scraper",
                "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/kdatafactory~naver-webtoon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kdatafactory-naver-webtoon-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "weekday",
                            "completed"
                        ],
                        "type": "string",
                        "description": "'weekday' = the current weekly lineup (the site's weekday tabs). 'completed' = the finished-series catalog (~3,000 titles, paginated).",
                        "default": "weekday"
                    },
                    "week": {
                        "title": "Weekday",
                        "enum": [
                            "all",
                            "mon",
                            "tue",
                            "wed",
                            "thu",
                            "fri",
                            "sat",
                            "sun",
                            "dailyPlus"
                        ],
                        "type": "string",
                        "description": "Weekday tab to scrape (weekday mode only). 'all' pulls every tab Mon–Sun in a single request; 'dailyPlus' is the 매일+ (Daily+) tab of daily webtoons.",
                        "default": "all"
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "user",
                            "view",
                            "update"
                        ],
                        "type": "string",
                        "description": "Result ordering. 'user' = user star rating, 'view' = cumulative views, 'update' = latest update. Note: view_count fully populates only in completed mode with order 'view'; the weekday lineup sorts by views but exposes the count for only a few titles.",
                        "default": "user"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of webtoons to return. The full weekly lineup is ~780 rows (one per weekday slot); the completed catalog is ~3,000 titles (paginated at 45 per request).",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy. The titlelist API is not IP-blocked (datacenter friendly), so a proxy is not required; enable one for IP diversity at scale.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```