# Olx Product Search Scraper (`scrapier/olx-product-search-scraper`) Actor

🛒 OLX Product Search Scraper pulls products from OLX search results—titles, prices, location, photos, seller, categories & links. ⚙️ Supports keywords, filters & pagination; exports CSV/JSON. 🚀 Perfect for price tracking, market research, lead gen & e‑commerce insights.

- **URL**: https://apify.com/scrapier/olx-product-search-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 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.

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

### Olx Product Search Scraper

Olx Product Search Scraper is an OLX scraper that pulls structured listing data from OLX search results and pages — titles, prices, location, photos, seller, categories, and links — so you can analyze, compare, and act on marketplace insights. It solves the manual and error-prone process of copy-pasting OLX listings by automating collection from OLX links or keyword-driven searches. Built for marketers, developers, data analysts, and researchers, this OLX product search scraper helps you scrape OLX search results at scale for price tracking, market research, lead generation, and e‑commerce insights.

### What data / output can you get?

Below are the exact fields this OLX data extractor exports to the Apify dataset. You can download results in CSV or JSON.

| Data type     | Description                                                                 | Example value |
| --- | --- | --- |
| id | Listing identifier parsed from OLX item data | "1234567890" |
| url | Canonical OLX item URL | "https://www.olx.in/item/1234567890" |
| name | Listing title/name | "Mercedes-Benz S-Class 2019 Diesel" |
| description | Full listing description text (if present) | "Well-maintained, single owner, service history available..." |
| details | Structured attributes map (Brand, Model, Variant, Year, Fuel, Transmission, KM driven, No. of Owners) | {"Brand":"mercedes-benz","Model":"s class","Variant":"S 350d","Year":"2019","Fuel":"Diesel","Transmission":"Automatic","KM driven":"45,000","No. of Owners":"1"} |
| sku | SKU from structured data (if present) | "MB-S350D-2019" |
| category | Category from structured data (if present) | "Cars" |
| total_views | View count placeholder (may be null if not available) | null |
| created_time | Listing creation timestamp (if available) | "2024-11-20T10:35:22+05:30" |
| location | City/region extracted from page | "Mumbai, Maharashtra" |
| image_urls | Array of image URLs gathered from the listing | ["https://images.olxcdn.com/img1.jpg","https://images.olxcdn.com/img2.jpg"] |
| price | Numeric price parsed from the listing payload | 5250000 |
| currency | Currency code (defaults to "INR" if unavailable) | "INR" |
| seller | Seller name extracted from structured data (if available) | "Elite Motors" |
| from_url | The source page or search item URL this record came from | "https://www.olx.in/item/1234567890" |

Note: Some fields (e.g., total_views, sku, category, seller) may be missing on certain listings and can return null. Exports are available directly from the Apify dataset in CSV and JSON.

### Key features

- 🚦 Bold dual‑mode input (URLs or keywords) — Paste full OLX links to parse page listings directly, or enter plain keywords to run an OLX India search, then open each result automatically.
- 🎯 Structured product details — Clean extraction of name, price, currency, location, images, seller, category, and a rich details object (Brand, Model, Variant, Year, Fuel, Transmission, KM driven, No. of Owners).
- 📊 Result limits per step — Control volume with maxItems (1–5,000) per OLX link or per keyword search for fast iterations or deeper crawls.
- 🔁 Robust retry logic — Configure maxRetries (0–10) to handle flaky responses and improve success rates on busy regions.
- 🛡️ Proxy support when needed — Use proxyConfiguration to switch from no proxy (default) to Apify Datacenter or Residential proxies if you encounter blocks; OLX .br often works best with US Datacenter per the scraper’s guidance.
- 💾 Easy data export — Results are stored in your Apify dataset so you can export to CSV or JSON for analysis, reporting, or pipelines.
- ⚙️ Production-ready scraping — Lightweight HTTP client with retry routines and anti-block checks for a reliable OLX listings crawler.

### How to use Olx Product Search Scraper - step by step

1. Create or log in to your Apify account.
2. Open the Olx Product Search Scraper actor.
3. Add input in “OLX page URLs or search keywords”:
   - Use full OLX links (e.g., listing or category pages), one per line.
   - Or use plain keywords (e.g., mercedes-benz). Keyword entries run an OLX India search first and then open each found listing.
4. Set “Limit listings per step” (maxItems). This applies per OLX link or per keyword search.
5. Open “Scrape options”:
   - Set “Limit the number of retries for each URL” (maxRetries) to improve reliability.
   - Configure “Proxy configuration” if you see empty/blocked pages. Default is no proxy; for OLX .br, try Datacenter with country US.
6. Click Start. The OLX web scraping tool will fetch each page or search, parse items, and push structured rows to the dataset.
7. Download results from the run’s Dataset in CSV or JSON.

Pro Tip: Mix category URLs with targeted keywords to automate OLX product search across segments (e.g., specific brands or models). Adjust maxItems to balance speed and dataset size.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research on OLX categories | Analyze supply, pricing, and categories by collecting structured listing data at scale from OLX pages or search results. |
| Price tracking & benchmarking | Monitor price and currency for recurring keywords or categories; build time series for an OLX price scraper workflow. |
| Lead generation for sellers | Extract seller names and listing links to qualify outreach lists for services, financing, or trade-ins. |
| E‑commerce inventory scouting | Identify product availability, attributes, and image sets to inform sourcing or resale strategies. |
| Real estate or vehicles comps | Aggregate location, price, and details for consistent comparables across regions and models. |
| Academic & trend analysis | Study classifieds dynamics using public OLX data for longitudinal research or regional insights. |

### Why choose Olx Product Search Scraper?

This OLX marketplace scraper is built for precision, automation, and dependable results on public listings.

- 🎯 Accurate field coverage: Extracts titles, prices, locations, images, seller, categories, and a detailed attributes object.
- 🔍 Flexible inputs: Works with both OLX links and plain keywords to scrape OLX search results automatically.
- 📈 Scales by design: maxItems per step (1–5,000) plus configurable retries let you tune speed and depth.
- 🧑‍💻 Developer-friendly outputs: Structured JSON in the dataset for straightforward processing or downstream pipelines.
- 🛡️ Resilient to friction: Optional proxy configuration helps when sites are picky or traffic is high.
- 💰 Cost-effective automation: Export clean CSV/JSON without browser extensions or brittle manual workflows.

In short, it’s a reliable OLX listings crawler that outperforms ad‑hoc scripts and unstable extensions by focusing on clean fields and repeatable runs.

### Is it legal / ethical to use Olx Product Search Scraper?

Yes — when used responsibly. This OLX classifieds scraper is designed to extract publicly available listing data only and does not access private or authenticated content.

Guidelines for compliant use:
- Scrape only public OLX listings and respect the platform’s terms.
- Avoid personal or sensitive information and honor applicable regulations (e.g., GDPR/CCPA).
- Use a proxy only when necessary to retrieve public pages reliably.
- Consult your legal team for edge cases or regional requirements.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "mercedes-benz",
    "https://www.olx.in/vile-parle-east_g5371523/cars_c84?filter=make_eq_mercedes-benz%2Cmodel_eq_mercedes-benz-s-class"
  ],
  "maxItems": 20,
  "maxRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array | Yes | — | Full OLX links (listing or category pages) or a keyword like “mercedes-benz” to search OLX India. One row per step; keywords run a search first, then each result is opened. |
| maxItems | integer | Yes | 20 | Max listings per OLX link or per keyword search. Lower is faster; higher returns more rows. Range: 1–5,000. |
| maxRetries | integer | No | 2 | Extra tries per link if the first attempt fails. Range: 0–10. |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Default: no proxy. Switch to Datacenter or Residential if blocked. On .br OLX, many users pick Datacenter with country US. |

#### Example JSON output

```json
{
  "id": "1234567890",
  "url": "https://www.olx.in/item/1234567890",
  "name": "Mercedes-Benz S-Class 2019 Diesel",
  "description": "Well-maintained, single owner, service history available...",
  "details": {
    "Brand": "mercedes-benz",
    "Model": "s class",
    "Variant": "S 350d",
    "Year": "2019",
    "Fuel": "Diesel",
    "Transmission": "Automatic",
    "KM driven": "45000",
    "No. of Owners": "1"
  },
  "sku": "MB-S350D-2019",
  "category": "Cars",
  "total_views": null,
  "created_time": "2024-11-20T10:35:22+05:30",
  "location": "Mumbai, Maharashtra",
  "image_urls": [
    "https://images.olxcdn.com/img1.jpg",
    "https://images.olxcdn.com/img2.jpg"
  ],
  "price": 5250000,
  "currency": "INR",
  "seller": "Elite Motors",
  "from_url": "https://www.olx.in/item/1234567890"
}
```

Notes:

- total\_views may be null when not present on the page.
- sku, category, seller can be missing on some listings.
- currency defaults to "INR" if not provided by the page payload.

### FAQ

#### Does this OLX scraper work with keywords and links?

✅ Yes. If an entry in startUrls is a full OLX link, the actor opens and parses that page. If it’s a plain keyword, it runs an OLX India search first, then opens each found listing.

#### Do I need to log in or provide cookies?

❌ No. The actor fetches public pages without login and parses publicly available listing data.

#### Which OLX country sites are supported?

🌍 Any OLX link you provide is opened as-is. Keyword searches run on OLX India; for other regions, supply direct OLX URLs from those country sites.

#### How many items can I scrape per run?

📈 Control volume with maxItems per step (1–5,000). It applies per OLX link or per keyword search entry.

#### What data fields are returned?

🧾 Each record includes id, url, name, description, details, sku, category, total\_views, created\_time, location, image\_urls, price, currency, seller, and from\_url.

#### How can I avoid blocks or empty pages?

🛡️ Use proxyConfiguration. By default, no proxy is used. If you see blocks, switch to Apify Datacenter or Residential proxies. For OLX .br, using a Datacenter proxy with country US is often effective.

#### How do I export the results?

💾 Results are saved to your Apify dataset. Download in CSV or JSON from the run’s Dataset section.

#### Can I automate this with an OLX scraping Python script or API?

🔗 You can run this actor on Apify and programmatically fetch the dataset via the platform’s API. Exported CSV/JSON makes it easy to plug into existing data workflows.

### Closing thoughts

Olx Product Search Scraper is built to automate OLX product data scraping from public listings with clean, structured outputs. It helps marketers, developers, data analysts, and researchers automate OLX product search, scrape OLX search results reliably, and export to CSV/JSON for downstream use. Configure maxItems and retries for scale, add proxies if needed, and integrate the dataset into your analytics or enrichment stack. Start extracting smarter OLX marketplace insights with a reliable OLX listings crawler today.

# Actor input Schema

## `startUrls` (type: `array`):

📋 **Full OLX links** (https://www.olx… listing or category pages) **or** a **keyword** like `mercedes-benz` to search OLX India (same idea as typing a query on OLX). ✨ One row per step, processed in order. Keywords are not opened as websites — they run a product search first, then each result is opened.

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

🎚️ Max listings per **OLX link** or per **keyword search** (search returns up to this many results, then each is opened). 📉 Lower = faster; 📈 higher = more rows.

## `maxRetries` (type: `integer`):

💪 How many **extra tries** per link if the first shot doesn’t work. Example: **2** here means up to **three** tries in total — handy on flaky networks or busy sites.

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

🌐 **Default:** no proxy — simplest setup. 🚀 If you hit blocks or empty pages, switch to **Datacenter** or **Residential** here. 🇧🇷 On **.br** OLX, many users pick **Datacenter** with country **US**.

## Actor input object example

```json
{
  "startUrls": [
    "mercedes-benz",
    "https://www.olx.in/vile-parle-east_g5371523/cars_c84?filter=make_eq_mercedes-benz%2Cmodel_eq_mercedes-benz-s-class"
  ],
  "maxItems": 20,
  "maxRetries": 2,
  "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 = {
    "startUrls": [
        "mercedes-benz",
        "https://www.olx.in/vile-parle-east_g5371523/cars_c84?filter=make_eq_mercedes-benz%2Cmodel_eq_mercedes-benz-s-class"
    ],
    "maxRetries": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/olx-product-search-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 = {
    "startUrls": [
        "mercedes-benz",
        "https://www.olx.in/vile-parle-east_g5371523/cars_c84?filter=make_eq_mercedes-benz%2Cmodel_eq_mercedes-benz-s-class",
    ],
    "maxRetries": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/olx-product-search-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 '{
  "startUrls": [
    "mercedes-benz",
    "https://www.olx.in/vile-parle-east_g5371523/cars_c84?filter=make_eq_mercedes-benz%2Cmodel_eq_mercedes-benz-s-class"
  ],
  "maxRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/olx-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Olx Product Search Scraper",
        "description": "🛒 OLX Product Search Scraper pulls products from OLX search results—titles, prices, location, photos, seller, categories & links. ⚙️ Supports keywords, filters & pagination; exports CSV/JSON. 🚀 Perfect for price tracking, market research, lead gen & e‑commerce insights.",
        "version": "1.0",
        "x-build-id": "CDkeIkUhEeu4vnUrj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~olx-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-olx-product-search-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/scrapier~olx-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-olx-product-search-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/scrapier~olx-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-olx-product-search-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": [
                    "startUrls",
                    "maxItems"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 OLX page URLs or search keywords",
                        "type": "array",
                        "description": "📋 **Full OLX links** (https://www.olx… listing or category pages) **or** a **keyword** like `mercedes-benz` to search OLX India (same idea as typing a query on OLX). ✨ One row per step, processed in order. Keywords are not opened as websites — they run a product search first, then each result is opened.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "🔢 Limit listings per step",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "🎚️ Max listings per **OLX link** or per **keyword search** (search returns up to this many results, then each is opened). 📉 Lower = faster; 📈 higher = more rows.",
                        "default": 20
                    },
                    "maxRetries": {
                        "title": "🔁 Limit the number of retries for each URL",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "💪 How many **extra tries** per link if the first shot doesn’t work. Example: **2** here means up to **three** tries in total — handy on flaky networks or busy sites.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy configuration",
                        "type": "object",
                        "description": "🌐 **Default:** no proxy — simplest setup. 🚀 If you hit blocks or empty pages, switch to **Datacenter** or **Residential** here. 🇧🇷 On **.br** OLX, many users pick **Datacenter** with country **US**."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
