# RIDI Bestseller Scraper — Korean Ebooks, Webnovels & Webtoons (`kdatafactory/ridibooks-scraper`) Actor

Scrape RIDI (리디), a major Korean ebook + webnovel/webtoon store: bestseller rank, title, author, publisher, KRW price, rating and cover as clean JSON. For webnovel/webtoon IP scouting, publishing scouts and bestseller tracking. Pairs with yes24 and naver-webtoon scrapers.

- **URL**: https://apify.com/kdatafactory/ridibooks-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.00 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## RIDI Bestseller Scraper — Korean Ebooks, Webnovels & Webtoons 📚

Scrape live **bestseller charts** from [RIDI (리디)](https://ridibooks.com) — one of Korea's biggest **ebook, webnovel and webtoon** stores — as clean, structured JSON. Get rank, title, author, publisher, price (KRW), rating, and cover image for every book on the chart in one run.

RIDI is where Korea's **webnovel and webtoon** demand becomes measurable: its serial charts surface the original stories that feed the K-drama and webtoon-adaptation pipeline, long before they trend. This actor turns those public charts into a dataset you can filter, rank-track, and pipe into your own tools — for **IP scouting**, publishing research, and bestseller monitoring.

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

---

### What it does

This actor reads bestseller data straight from RIDI's own public sources — the server-rendered bestseller page (page 1) and the same public GraphQL API the site calls for "load more" (pages 2+) — so results are fast and complete, with no headless browser. The **bestseller list is fully public** (only *reading* a book is paywalled), so no login is required. You can scrape any of RIDI's bestseller charts:

| Category (alias) | RIDI chart | Notes |
|------------------|-----------|-------|
| `general` (default), `all` | 일반 단행본 — general trade e-books | The site's default bestseller view |
| `ebook` | All e-books | Broad e-book chart |
| `webnovel` | 웹소설 — webnovels (serials) | Original-story IP pipeline |
| `webtoon` | 웹툰 — webtoons | Daily chart |
| `comic` | 만화 — comics/manga | |
| `fantasy` | 판타지 e-book | Also `fantasy_serial` (판타지 웹소설) |
| `romance` | 로맨스 e-book | Also `romance_serial` (로맨스 웹소설) |
| `romance-fantasy` | 로판 (romance-fantasy) e-book | Also `romance_fantasy_serial` |
| `lightnovel` | 라이트노벨 | |

Power users can pass **any raw RIDI genre slug** (e.g. `general`, `serial`, `comic_serial`) directly. RIDI's bestseller chart holds up to **200 ranked books per genre**.

> **Why RIDI?** Korean webnovels and webtoons are the raw material of the global K-content boom — a huge share of hit K-dramas and webtoons start as serialized web fiction. RIDI is one of the largest stores for exactly that content, and its bestseller charts are an early, ranked signal of what's resonating with Korean readers **right now**.

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `category` | string | Which bestseller chart to scrape. A friendly alias — `all`/`general`, `ebook`, `webnovel`, `webtoon`, `comic`, `fantasy`, `romance`, `romance-fantasy`, `lightnovel` — or a raw RIDI genre slug (e.g. `general`, `serial`, `fantasy_serial`). Blank = `general`. |
| `maxItems` | integer | Max records to collect. Default `100`, max `200` (RIDI's chart caps at 200 per genre). |
| `proxyConfiguration` | object | Proxy settings (see below). Defaults to a direct connection. |

#### Input example

```json
{
  "category": "webnovel",
  "maxItems": 200
}
````

```json
{
  "category": "general",
  "maxItems": 100
}
```

***

### Output

Each bestseller is one dataset record, in chart order. `rank` is the book's position on the chart (1 = top). `price_krw` is the discounted selling price in Korean won. `rating` is the average of RIDI's 1–5 star reader ratings. `title` keeps the full original book/episode name.

```json
{
  "source": "ridi",
  "rank": 1,
  "book_id": "4239000438",
  "title": "신 퇴마록 신세편 1권",
  "author": "이우혁",
  "publisher": "반타",
  "price_krw": 16200,
  "rating": 4.18,
  "category": "general",
  "url": "https://ridibooks.com/books/4239000438",
  "image_url": "https://img.ridicdn.net/cover/4239000438/xxlarge",
  "scraped_at": "2026-07-14T14:45:46+09:00"
}
```

A full 40-item sample from a real run is in [`samples/sample-output.json`](samples/sample-output.json).

| Field | Meaning |
|-------|---------|
| `source` | Always `"ridi"`. |
| `rank` | Position on the bestseller chart (1 = top). |
| `book_id` | RIDI book ID. |
| `title` | Full original book / episode title (Korean). |
| `author` | Public creator name(s), as RIDI lists them. Webtoons list all roles (writer / illustrator / original author), comma-joined. |
| `publisher` | Publisher / label (Korean), else `null`. |
| `price_krw` | Discounted selling price in KRW, else `null` (see limitations — webnovel/webtoon episodes are often free or per-episode). |
| `rating` | Average reader rating, 1–5, else `null` when the book has no ratings yet. |
| `category` | The RIDI genre slug that was scraped (e.g. `general`, `serial`, `webtoon`). |
| `url` | Book detail page URL. |
| `image_url` | Cover image URL. |
| `scraped_at` | ISO-8601 timestamp (KST, UTC+9). |

The critical fields — `rank`, `title`, `author` — are populated on **40/40** records in the live test, along with `publisher`, `url`, `image_url`, and `category`. `price_krw` (40/40 on the `general` chart) and `rating` (35/40) are best-effort — see Known limitations.

***

### Use cases

- **Webnovel & webtoon IP scouting** — build a live, ranked catalogue of Korea's top serialized stories to scout source material for **K-drama, film, and webtoon adaptation** before it breaks out. Run the `webnovel` and `webtoon` charts on a schedule to catch rising titles early.
- **Publishing & rights scouts** — track which authors, publishers, and genres are climbing RIDI's charts to inform acquisitions, translation rights, and licensing.
- **Bestseller & trend tracking** — snapshot the charts daily to measure rank velocity, price positioning, and rating momentum across genres.
- **AI agents & datasets** — feed structured Korean-book chart data into dashboards, recommendation models, or LLM agents.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal bestseller-list data — the same charts any visitor sees on ridibooks.com without logging in. It never logs in and never accesses paywalled book content. Author names are the public creator credits RIDI publishes on every listing. You are responsible for how you use the data; see the legality note below.

**What does it cost in practice?**
$2.00 per 1,000 results (launch pricing) + a few cents of platform usage. A full 200-book chart pull costs about **$0.40**. Apify's free $5 monthly credit covers **~2,500 results**.

**Do I need to configure proxies?**
No — the default settings work out of the box. RIDI serves its bestseller data without a bot wall, so the actor runs fine on a **direct connection**. For very heavy scheduled pulls you can optionally enable Apify Proxy — see the proxy note below.

**How fresh is the data?**
Every run scrapes the live RIDI charts at run time. Schedule the actor for recurring snapshots (e.g. daily rank tracking).

**Which categories can I scrape?**
Any RIDI bestseller genre — `general` (default), `ebook`, `webnovel`, `webtoon`, `comic`, `fantasy`, `romance`, `romance-fantasy`, `lightnovel`, and their raw slugs (e.g. `serial`, `fantasy_serial`). See the table above.

**What is NOT included?**
Paywalled book content (we never fetch it) and any account/personal data. `price_krw` and `rating` are best-effort (see limitations). Titles, authors, and publishers come as Korean strings — RIDI is a Korean-language store.

***

### 🤖 Use with AI agents (MCP)

Call this Actor as a tool from Claude or any MCP-compatible AI agent — no glue code. Point your MCP client at Apify's server, scoped to this Actor:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=kdatafactory/ridibooks-scraper",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Your agent can then pull RIDI ebook, webnovel, and webtoon bestseller charts on demand — no scraping code in your app. Grab a free token from [Apify → Integrations](https://console.apify.com/settings/integrations).

### 🇰🇷 More Korean data actors

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

- **[yes24-bestseller-scraper](https://apify.com/kdatafactory/yes24-bestseller-scraper) — bestseller charts from Yes24, Korea's largest online bookstore.** Pair it with this actor to cover both print and digital Korean book demand.
- **[naver-webtoon-scraper](https://apify.com/kdatafactory/naver-webtoon-scraper) — series & rankings from Naver Webtoon, Korea's #1 webtoon platform.** Run it alongside RIDI's webtoon chart for cross-platform webtoon IP scouting.

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

***

### Rate limiting & legality

- The actor collects **only public, non-authenticated data** — the public bestseller charts. It never logs in and never touches paywalled book content or private endpoints.
- **No personal / account data** is collected. Only bestseller-list book metadata and the public creator (author) credit RIDI publishes on each listing are returned.
- Requests are rate-limited: one page at a time with a ≥ 500 ms delay between requests, to stay gentle on RIDI's servers.
- You are responsible for using the data in line with RIDI's terms of service and applicable law.

#### Known limitations (honesty note)

- **`price_krw` is best-effort.** On the `general`, `ebook`, and `comic` charts it's the book's discounted selling price and is well-populated. On the `webnovel`/`webtoon` (serial) charts, the chart entry is usually a **first episode that's free or priced per-episode**, so `price_krw` is often `null` — that's honest, not a bug. It is not billed as a guaranteed field.
- **`rating` is best-effort.** It's the weighted average of RIDI's 1–5 star reader ratings, and is `null` when a book has no ratings yet (about 1 in 8 books on the live `general` chart). Rounded to two decimals.
- **`publisher` can be `null`** when RIDI doesn't expose a publisher/label for a listing (rare on the tested charts, but possible on some serials).
- **Text is Korean.** RIDI is a Korean-language store, so titles, author names, and publishers are returned as Korean strings and are not translated.
- **The chart caps at 200.** RIDI's bestseller list returns at most 200 books per genre, so `maxItems` above 200 is clamped to 200.

***

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

# Actor input Schema

## `category` (type: `string`):

Which RIDI bestseller chart to scrape. Accepts a friendly alias — 'all'/'general' (일반 단행본 e-books), 'ebook' (all e-books), 'webnovel' (웹소설), 'webtoon' (웹툰), 'comic' (만화), 'fantasy', 'romance', 'romance-fantasy' (로판), 'lightnovel' — or a raw RIDI genre slug (e.g. 'general', 'serial', 'fantasy\_serial', 'romance\_serial', 'comic\_serial'). Leave blank for 'general'.

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

Maximum number of bestseller records to collect. RIDI's bestseller chart tops out at 200 per genre.

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

Proxy settings. RIDI serves its bestseller data without a bot wall, so the actor runs fine on a direct connection (default). If you ever see blocks at high volume, enable Apify Proxy here.

## Actor input object example

```json
{
  "category": "general",
  "maxItems": 100,
  "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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("kdatafactory/ridibooks-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("kdatafactory/ridibooks-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 '{}' |
apify call kdatafactory/ridibooks-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RIDI Bestseller Scraper — Korean Ebooks, Webnovels & Webtoons",
        "description": "Scrape RIDI (리디), a major Korean ebook + webnovel/webtoon store: bestseller rank, title, author, publisher, KRW price, rating and cover as clean JSON. For webnovel/webtoon IP scouting, publishing scouts and bestseller tracking. Pairs with yes24 and naver-webtoon scrapers.",
        "version": "0.1",
        "x-build-id": "IatgRaQ9BFZV9WFxa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kdatafactory~ridibooks-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kdatafactory-ridibooks-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~ridibooks-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kdatafactory-ridibooks-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~ridibooks-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kdatafactory-ridibooks-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",
                "properties": {
                    "category": {
                        "title": "Category (bestseller genre)",
                        "type": "string",
                        "description": "Which RIDI bestseller chart to scrape. Accepts a friendly alias — 'all'/'general' (일반 단행본 e-books), 'ebook' (all e-books), 'webnovel' (웹소설), 'webtoon' (웹툰), 'comic' (만화), 'fantasy', 'romance', 'romance-fantasy' (로판), 'lightnovel' — or a raw RIDI genre slug (e.g. 'general', 'serial', 'fantasy_serial', 'romance_serial', 'comic_serial'). Leave blank for 'general'.",
                        "default": "general"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of bestseller records to collect. RIDI's bestseller chart tops out at 200 per genre.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. RIDI serves its bestseller data without a bot wall, so the actor runs fine on a direct connection (default). If you ever see blocks at high volume, enable Apify Proxy here.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
