# Kurly Scraper — Market Kurly Grocery Prices, Rankings & Search (`kdatafactory/kurly-scraper`) Actor

Scrape Market Kurly (kurly.com), Korea premium grocery & food store. Best-seller rankings, keyword search and category listings as clean JSON: product name, KRW price, sale price, discount rate, sold-out status, image and URL. For K-food market research, price monitoring and AI agents.

- **URL**: https://apify.com/kdatafactory/kurly-scraper.md
- **Developed by:** [Seok June Park](https://apify.com/kdatafactory) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 0 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

## Market Kurly Scraper 🛒

Scrape **keyword search, category listings, and best-seller rankings** from
[Market Kurly](https://www.kurly.com) (마켓컬리) — Korea's leading **premium grocery
and fresh-food** e-commerce platform. Get clean, structured product data
(name, KRW price, sale price, discount rate, sold-out status, review volume,
image, product URL) in JSON, CSV, or Excel.

Built for **K-food market researchers, price-monitoring teams, and sourcing
analysts** who need to track what is actually selling in Korea's premium
grocery market.

> **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 a **query** and it returns a structured product feed:

| Mode | What you get | Example input |
|------|--------------|---------------|
| `search` | Products matching a **keyword**, paginated & sortable | `{ "mode": "search", "query": "우유" }` |
| `category` | Products in a **top-level category** | `{ "mode": "category", "query": "과일·견과·쌀" }` |
| `ranking` | A category's **best-seller (sales-volume) ranking**, with `rank` | `{ "mode": "ranking", "query": "018" }` |

Data comes straight from Market Kurly's own **public JSON API** (`api.kurly.com`,
the same endpoints the website's front-end calls) — so it is fast and reliable,
no brittle HTML scraping.

**Category names → codes** (pass either the name or the code as `query`):

| Code | Category | Code | Category |
|------|----------|------|----------|
| `907` | 채소 (Vegetables) | `914` | 생수·음료 (Water & Drinks) |
| `908` | 과일·견과·쌀 (Fruit / Nuts / Rice) | `383` | 커피·차 (Coffee & Tea) |
| `909` | 수산·해산·건어물 (Seafood) | `249` | 간식·과자·떡 (Snacks) |
| `910` | 정육·가공육·달걀 (Meat & Eggs) | `915` | 베이커리 (Bakery) |
| `911` | 국·반찬·메인요리 (Sides & Meals) | `018` | 유제품 (Dairy) |
| `912` | 간편식·밀키트·샐러드 (Meal Kits) | `032` | 건강식품 (Health Food) |
| `913` | 면·양념·오일 (Noodles / Sauce / Oil) | `722` | 와인·위스키 (Wine & Whisky) |

(Full list — including non-food categories like 뷰티, 생활용품, 반려동물 — is in
`src/constants.js`.)

---

### 📥 Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `search` | `search`, `category`, or `ranking`. |
| `query` | string | — | Keyword (search) or category name/code (category & ranking). **Required.** |
| `maxItems` | integer | `100` | Max products to return across pages. |
| `sort` | string | `RECOMMENDED` | `RECOMMENDED`, `NEWEST`, `BEST_SELLING`, `BENEFIT`, `PRICE_LOW`, `PRICE_HIGH`. (`ranking` mode forces best-selling order.) |
| `enrichBrand` | boolean | `false` | Fetch `brand` + exact `review_count` per product (slower — one extra request each). See note below. |
| `proxyConfiguration` | object | RESIDENTIAL | Apify proxy. Korea RESIDENTIAL recommended. |

**Input example — top dairy products by sales, with brand names:**

```json
{
  "mode": "ranking",
  "query": "018",
  "maxItems": 100,
  "enrichBrand": true
}
````

***

### 📤 Output

Each product is one dataset record (real sample from a live run, `enrichBrand` on):

```json
{
  "source": "kurly",
  "product_id": "5097217",
  "name": "[매일] 바이오 그릭 요거트 무가당 플레인 400g",
  "brand": "매일유업",
  "price_krw": 4680,
  "sale_price_krw": 3780,
  "discount_rate": 19,
  "category": "category/018",
  "is_sold_out": false,
  "review_count_text": "9,999+",
  "review_count": 79324,
  "rank": 1,
  "url": "https://www.kurly.com/goods/5097217",
  "image_url": "https://product-image.kurly.com/product/image/22702b7a-669f-4e3d-9c2b-4c828993b200.jpg",
  "scraped_at": "2026-07-09T13:24:27.539+09:00"
}
```

**Field notes (read this — honesty matters)**

- `price_krw` — the list price in **KRW**. `sale_price_krw` — the discounted
  price when the product is on sale, otherwise `null`. `discount_rate` — integer
  percent (0 when not discounted). These populate reliably in **every** mode.
- `is_sold_out` — boolean. Populates reliably.
- `review_count_text` — a **bucketed label** exactly as Kurly shows it in list
  views (e.g. `"999+"`, `"9,999+"`). It is *not* an exact number; it is surfaced
  as text so it is never mistaken for one. Populates reliably.
- `brand` and exact numeric `review_count` — **only populated when
  `enrichBrand: true`** (they are not present in Kurly's list API and require one
  extra product-detail request each). With `enrichBrand` off, both are `null`.
  Even with it on, a few third-party products have no registered brand (`null`).
- `rank` — 1-based position within the returned ordering. In `ranking` mode this
  is the best-seller position.
- A full 25-record sample lives in [`samples/sample-output.json`](samples/sample-output.json).

***

### 💡 Use cases

- **K-food & grocery market research** — see what is trending in Korea's premium
  grocery market by category and sales rank.
- **Price & promotion monitoring** — track KRW prices, sale prices, and discount
  rates on hero SKUs over time.
- **Sourcing / import scouting** — find high-selling Korean grocery products with
  images and URLs ready to evaluate.
- **AI agents & LLM pipelines** — feed a clean JSON grocery catalog into RAG or a
  shopping assistant.
- **Competitive intelligence** — monitor best-seller ranking shifts across
  categories.

***

### 🌐 Data source & proxy

This actor targets **Market Kurly** (`www.kurly.com` / `api.kurly.com`), reading
only the storefront's **public** search, category, and product JSON APIs. Prices
and names are in **Korean / KRW** (this is the Korean-domestic storefront).

> **⚠️ Use Apify RESIDENTIAL (Korea) proxy.** Kurly's CDN/WAF can rate-limit or
> geo-filter non-Korean and datacenter IPs. The default input keeps `RESIDENTIAL`
> proxy enabled — leave it on. Every request also **falls back to a direct
> connection** if the proxy tunnel fails, so a bad proxy never silently kills a
> run. If a challenge page is returned instead of JSON, the run fails with a clear
> "Blocked by anti-bot" error.

***

### ⚖️ Rate & legality note

- Only **public, non-personal** catalog data is collected — product listings that
  anyone can browse without logging in. **No customer, reviewer, or seller
  personal data** (no nicknames, profiles, IDs, phone numbers) is ever scraped.
  Reviews are represented only as an aggregate count.
- Requests are **rate-limited** (sequential pages, ≥ 500 ms delay) to stay light
  on the site.
- You are responsible for complying with Market Kurly's Terms of Service and
  applicable law in your jurisdiction. Use the data for research, monitoring, and
  analytics — not to replicate the storefront.

***

### ❓ FAQ

**Is it legal to scrape this data?**
This actor collects only public, non-personal catalog data — the same product listings any visitor sees on Market Kurly without logging in. No customer, reviewer, or seller personal data is collected. You are responsible for how you use the data; see the legality note above.

**What does it cost in practice?**
$2.50 per 1,000 results (launch pricing) + a few cents of platform usage. Example: a 500-result daily pull costs about $1.25/day. 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 (RESIDENTIAL proxy is pre-enabled, with automatic direct-connection fallback). For heavy pulls, keeping Korea RESIDENTIAL proxy on is recommended since Kurly's CDN can rate-limit non-Korean and datacenter IPs.

**How fresh is the data?**
Every run scrapes the live site at run time. Schedule the actor for recurring snapshots.

**What is NOT included?**
No personal data of any kind — reviews appear only as an aggregate count, and `review_count_text` is the bucketed label Kurly itself shows (e.g. `"9,999+"`), not an exact number. `brand` and exact numeric `review_count` are only populated when `enrichBrand: true` (slower, one extra request per product).

***

### 🤖 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/kurly-scraper",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Your agent can then pull Market Kurly grocery prices & rankings 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:

- [oliveyoung-scraper](https://apify.com/kdatafactory/oliveyoung-scraper) — Olive Young K-beauty product listings and rankings.
- [naver-place-scraper](https://apify.com/kdatafactory/naver-place-scraper) — Naver Place local business listings and details.

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
KURLY_SCRAPER_LITE_TEST=1 npm start   # lite guard: ≤2 pages / ~40 items
```

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/kurly-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`):

What to scrape. 'search' = keyword search results. 'category' = products in a top-level category. 'ranking' = the best-seller (sales) ranking of a category.

## `query` (type: `string`):

For 'search': the keyword (e.g. "우유", "딸기", "라면"). For 'category' and 'ranking': a category name (e.g. "과일·견과·쌀", "유제품") or a numeric category code (e.g. "908", "018"). See README for the category list.

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

Maximum number of products to return across all pages.

## `sort` (type: `string`):

Result ordering. 'ranking' mode forces sales-volume order regardless of this value.

## `enrichBrand` (type: `boolean`):

When enabled, the actor makes one extra request per product to the product-detail API to fill in 'brand' and an exact numeric 'review\_count'. This is much slower and adds one request per item, so leave it off unless you specifically need brand names. When off, 'brand' is null and 'review\_count' is a bucketed label (e.g. "999+").

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

Apify proxy settings. RESIDENTIAL (Korea) is recommended for reliable, unblocked access to the storefront API.

## Actor input object example

```json
{
  "mode": "search",
  "query": "우유",
  "maxItems": 100,
  "sort": "RECOMMENDED",
  "enrichBrand": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "query": "우유"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kurly Scraper — Market Kurly Grocery Prices, Rankings & Search",
        "description": "Scrape Market Kurly (kurly.com), Korea premium grocery & food store. Best-seller rankings, keyword search and category listings as clean JSON: product name, KRW price, sale price, discount rate, sold-out status, image and URL. For K-food market research, price monitoring and AI agents.",
        "version": "0.1",
        "x-build-id": "zuRVl4STnoYbSHLwQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kdatafactory~kurly-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kdatafactory-kurly-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~kurly-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kdatafactory-kurly-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~kurly-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kdatafactory-kurly-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": [
                            "search",
                            "category",
                            "ranking"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'search' = keyword search results. 'category' = products in a top-level category. 'ranking' = the best-seller (sales) ranking of a category.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "For 'search': the keyword (e.g. \"우유\", \"딸기\", \"라면\"). For 'category' and 'ranking': a category name (e.g. \"과일·견과·쌀\", \"유제품\") or a numeric category code (e.g. \"908\", \"018\"). See README for the category list."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to return across all pages.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "RECOMMENDED",
                            "NEWEST",
                            "BEST_SELLING",
                            "BENEFIT",
                            "PRICE_LOW",
                            "PRICE_HIGH"
                        ],
                        "type": "string",
                        "description": "Result ordering. 'ranking' mode forces sales-volume order regardless of this value.",
                        "default": "RECOMMENDED"
                    },
                    "enrichBrand": {
                        "title": "Enrich brand & exact review count (slower)",
                        "type": "boolean",
                        "description": "When enabled, the actor makes one extra request per product to the product-detail API to fill in 'brand' and an exact numeric 'review_count'. This is much slower and adds one request per item, so leave it off unless you specifically need brand names. When off, 'brand' is null and 'review_count' is a bucketed label (e.g. \"999+\").",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. RESIDENTIAL (Korea) is recommended for reliable, unblocked access to the storefront API.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```