# Daraz Scraper (`crawlerbros/daraz-scraper`) Actor

Scrape Daraz, South Asia's largest online marketplace (Pakistan, Bangladesh, Sri Lanka, Nepal). Search products by keyword or category, filter by price, rating, and sort order, across all four country storefronts.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

## Daraz Scraper

Scrape **Daraz** — South Asia's largest online marketplace, covering Pakistan (daraz.pk), Bangladesh (daraz.com.bd), Sri Lanka (daraz.lk), and Nepal (daraz.com.np). Search products by keyword or browse Daraz's real category taxonomy (Mobiles & Tablets, Fashion, Health & Beauty, Groceries, and more), then filter by price range, star rating, and sort order. No login, no cookies, no paid proxy required.

### What this actor does

- **Two modes:** `search` (keyword) and `category` (browse Daraz's real navigation categories)
- **Four storefronts:** Pakistan, Bangladesh, Sri Lanka, Nepal — pick per run
- **Filters:** min/max price, minimum star rating, sort order (popularity / price low-high / price high-low), brand, shipped-from region, free-shipping only, in-stock only
- **Rich product data:** price, discount %, rating, review count, units sold, seller, shipping origin, and product images
- **Empty fields are omitted**

### Output per product

- `productId` — Daraz's internal item ID
- `title` — product listing title
- `price`, `priceFormatted` — numeric price and the storefront-formatted string (e.g. `Rs. 116,000`)
- `originalPrice`, `discountPercentage` — only present when the item is on sale
- `currency` — ISO code for the storefront (`PKR` / `BDT` / `LKR` / `NPR`)
- `rating`, `reviewCount` — only present when the product has reviews
- `itemsSoldText`, `itemsSold` — units sold, as shown and parsed to a number
- `brand`, `brandId`
- `sellerName`, `sellerId`
- `shippedFrom` — origin province/region as shown on the listing
- `imageUrl` — primary product image
- `productUrl` — canonical product page link
- `inStock`, `isSponsored`, `freeShipping`
- `categoryIds` — Daraz's internal category IDs for the product
- `countrySite` — which storefront the record came from (`pk` / `bd` / `lk` / `np`)
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (keyword) or `category` (browse) |
| `countrySite` | string | `pk` | `pk` / `bd` / `lk` / `np` — which Daraz storefront |
| `searchQuery` | string | `mobile phone` | Free-text keyword (mode=search; also narrows results within `mode=category`) |
| `category` | string | `phones-tablets` | Category to browse (mode=category) — see the dropdown for the full list |
| `brand` | string | – | Only keep products whose brand exactly matches this name (case-insensitive), e.g. `Samsung` |
| `shippedFrom` | string | – | Only keep products shipped from this region (case-insensitive exact match), e.g. `Punjab`, `Dhaka` |
| `freeShippingOnly` | boolean | `false` | Only keep products with a free-shipping badge |
| `inStockOnly` | boolean | `false` | Only keep products Daraz currently reports as in stock |
| `minPrice` | int | – | Drop products priced below this amount (local currency) |
| `maxPrice` | int | – | Drop products priced above this amount (local currency) |
| `minRating` | string | `0` | `0` (any) to `5` (5 stars only) |
| `sortBy` | string | `popularity` | `popularity` / `priceasc` / `pricedesc` |
| `maxItems` | int | `50` | Hard cap on emitted records (1–2000) |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Apify proxy config (AUTO datacenter group is sufficient) |

#### Example: keyword search with price range

```json
{
  "mode": "search",
  "countrySite": "pk",
  "searchQuery": "wireless earbuds",
  "minPrice": 1000,
  "maxPrice": 5000,
  "sortBy": "priceasc",
  "maxItems": 50
}
````

#### Example: browse a category, highly rated only

```json
{
  "mode": "category",
  "countrySite": "bd",
  "category": "beauty-health",
  "minRating": "4",
  "sortBy": "popularity",
  "maxItems": 100
}
```

#### Example: Nepal storefront, price high to low

```json
{
  "mode": "category",
  "countrySite": "np",
  "category": "computing",
  "sortBy": "pricedesc",
  "maxItems": 30
}
```

#### Example: Sri Lanka search, narrow by keyword within a category

```json
{
  "mode": "category",
  "countrySite": "lk",
  "category": "sports-travel",
  "searchQuery": "badminton",
  "maxItems": 40
}
```

### Use cases

- **Price monitoring** — track pricing and discounts on specific products or categories across South Asian markets
- **Market research** — compare product assortments and pricing between Pakistan, Bangladesh, Sri Lanka, and Nepal storefronts
- **Competitor analysis** — monitor seller listings, ratings, and units-sold signals for a category
- **Deal discovery** — filter by discount and rating to surface the best-value listings
- **Catalog enrichment** — pull structured product data (images, brand, seller) for downstream cataloging

### Data Source / Limitations

- Data comes from Daraz's own product-listing endpoint (the same one that powers the on-site search and category pages) — no scraping of unofficial mirrors or third-party resellers.
- Daraz's public search results page (`/catalog/`) is excluded by the site's `robots.txt`; this actor accesses it directly like the many third-party Daraz scrapers already on the market, and does not bypass any login, paywall, or CAPTCHA.
- `sortBy` only exposes the three sort orders Daraz's own UI provides (`popularity`, `priceasc`, `pricedesc`) — Daraz does not offer a distinct "newest" sort on product listings, so it is not included.
- `minRating` filters to Daraz's own rating buckets. Because most listings for a given search cluster at 4+ stars, low thresholds (1–3) and "any rating" often return very similar result sets — this reflects Daraz's actual rating distribution, not a bug.
- Category names and slugs reflect Daraz's real, currently-live navigation taxonomy as of the last verification pass; Daraz occasionally renames or merges categories.
- `brand` and `shippedFrom` are exact-match (case-insensitive) text filters rather than dropdowns — Daraz's brand and shipping-region lists differ per category/storefront and aren't a fixed, query-independent set, so they can't be enumerated reliably.

### FAQ

**Is this affiliated with Daraz?**  No. This is an independent, third-party actor that reads Daraz's public product-listing data. It is not endorsed by or affiliated with Daraz or Alibaba Group.

**Do I need a Daraz account, login, or API key?**  No. All modes work without authentication.

**Which countries are supported?**  Pakistan (`daraz.pk`), Bangladesh (`daraz.com.bd`), Sri Lanka (`daraz.lk`), and Nepal (`daraz.com.np`) — pick via `countrySite`.

**Can I combine keyword search with a category?**  Yes — set `mode` to `category` and also fill in `searchQuery` to narrow results to that keyword within the chosen category.

**Why do some products have no `rating` or `reviewCount`?**  Those fields are omitted when a product has no reviews yet — Daraz doesn't show a rating for unreviewed listings.

**Why is `originalPrice` sometimes missing?**  It's only included when the product is actively discounted. Full-price listings only have `price`.

**How fresh is the data?**  Real-time — every run queries Daraz's live listing endpoint directly.

**What does `itemsSoldText` vs `itemsSold` mean?**  `itemsSoldText` is Daraz's own display string (e.g. `"16.1K sold"`); `itemsSold` is that same value parsed into a plain number (`16100`) for easier filtering and sorting.

# Actor input Schema

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

What to fetch: search by keyword, or browse a category listing.

## `countrySite` (type: `string`):

Which Daraz storefront to scrape.

## `searchQuery` (type: `string`):

Free-text keyword (mode=search). Also used to narrow results within a category when mode=category.

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

Daraz category to browse (mode=category).

## `brand` (type: `string`):

Only keep products whose brand exactly matches this name (case-insensitive), e.g. `Dell`, `Samsung`, `Nike`. Matched against the brand Daraz shows on the listing — leave empty to include all brands. Narrower than a dropdown because Daraz doesn't expose a fixed, query-independent brand list.

## `shippedFrom` (type: `string`):

Only keep products shipped from this region (case-insensitive exact match), e.g. `Punjab`, `Sindh`, `Local`, `Overseas` (Pakistan); `Dhaka`, `Chattogram` (Bangladesh); `Western`, `Southern` (Sri Lanka); `Bagmati Province` (Nepal). Matches Daraz's own "Shipped From" filter — leave empty to include all regions.

## `freeShippingOnly` (type: `boolean`):

Only keep products that show a free-shipping / free-delivery badge.

## `inStockOnly` (type: `boolean`):

Only keep products Daraz currently reports as in stock.

## `minPrice` (type: `integer`):

Drop products priced below this amount (in the storefront's local currency).

## `maxPrice` (type: `integer`):

Drop products priced above this amount (in the storefront's local currency).

## `minRating` (type: `string`):

Only include products with at least this star rating.

## `sortBy` (type: `string`):

Result ordering, matching Daraz's own sort options.

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

Hard cap on the number of products emitted.

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

Daraz's product-listing API accepts plain datacenter traffic, so the free AUTO group is sufficient. Left on by default for IP diversity across large runs.

## Actor input object example

```json
{
  "mode": "search",
  "countrySite": "pk",
  "searchQuery": "mobile phone",
  "category": "phones-tablets",
  "freeShippingOnly": false,
  "inStockOnly": false,
  "minRating": "0",
  "sortBy": "popularity",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Daraz products.

# 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": "search",
    "countrySite": "pk",
    "searchQuery": "mobile phone",
    "category": "phones-tablets",
    "freeShippingOnly": false,
    "inStockOnly": false,
    "minRating": "0",
    "sortBy": "popularity",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/daraz-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": "search",
    "countrySite": "pk",
    "searchQuery": "mobile phone",
    "category": "phones-tablets",
    "freeShippingOnly": False,
    "inStockOnly": False,
    "minRating": "0",
    "sortBy": "popularity",
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/daraz-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": "search",
  "countrySite": "pk",
  "searchQuery": "mobile phone",
  "category": "phones-tablets",
  "freeShippingOnly": false,
  "inStockOnly": false,
  "minRating": "0",
  "sortBy": "popularity",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/daraz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Daraz Scraper",
        "description": "Scrape Daraz, South Asia's largest online marketplace (Pakistan, Bangladesh, Sri Lanka, Nepal). Search products by keyword or category, filter by price, rating, and sort order, across all four country storefronts.",
        "version": "1.0",
        "x-build-id": "l69Q1A2J1Q13sBp6C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~daraz-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-daraz-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/crawlerbros~daraz-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-daraz-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/crawlerbros~daraz-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-daraz-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",
                    "countrySite"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "category"
                        ],
                        "type": "string",
                        "description": "What to fetch: search by keyword, or browse a category listing.",
                        "default": "search"
                    },
                    "countrySite": {
                        "title": "Country site",
                        "enum": [
                            "pk",
                            "bd",
                            "lk",
                            "np"
                        ],
                        "type": "string",
                        "description": "Which Daraz storefront to scrape.",
                        "default": "pk"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword (mode=search). Also used to narrow results within a category when mode=category.",
                        "default": "mobile phone"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "phones-tablets",
                            "computing",
                            "camera",
                            "home-appliances",
                            "fashion",
                            "shoes-clothing",
                            "jewellery-watches-eyewear",
                            "beauty-health",
                            "mother-baby",
                            "furniture-decor",
                            "home-improvement-tools",
                            "grocers-shop",
                            "sports-travel",
                            "motors-vehicles",
                            "books-games-music"
                        ],
                        "type": "string",
                        "description": "Daraz category to browse (mode=category).",
                        "default": "phones-tablets"
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Only keep products whose brand exactly matches this name (case-insensitive), e.g. `Dell`, `Samsung`, `Nike`. Matched against the brand Daraz shows on the listing — leave empty to include all brands. Narrower than a dropdown because Daraz doesn't expose a fixed, query-independent brand list."
                    },
                    "shippedFrom": {
                        "title": "Shipped from",
                        "type": "string",
                        "description": "Only keep products shipped from this region (case-insensitive exact match), e.g. `Punjab`, `Sindh`, `Local`, `Overseas` (Pakistan); `Dhaka`, `Chattogram` (Bangladesh); `Western`, `Southern` (Sri Lanka); `Bagmati Province` (Nepal). Matches Daraz's own \"Shipped From\" filter — leave empty to include all regions."
                    },
                    "freeShippingOnly": {
                        "title": "Free shipping only",
                        "type": "boolean",
                        "description": "Only keep products that show a free-shipping / free-delivery badge.",
                        "default": false
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only keep products Daraz currently reports as in stock.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products priced below this amount (in the storefront's local currency)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products priced above this amount (in the storefront's local currency)."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "enum": [
                            "0",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only include products with at least this star rating.",
                        "default": "0"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "popularity",
                            "priceasc",
                            "pricedesc"
                        ],
                        "type": "string",
                        "description": "Result ordering, matching Daraz's own sort options.",
                        "default": "popularity"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on the number of products emitted.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Daraz's product-listing API accepts plain datacenter traffic, so the free AUTO group is sufficient. Left on by default for IP diversity across large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
