# OLX Scraper - Listings, Ad Details, Phone Numbers (`sourabhbgp/olx-scraper`) Actor

Scrape OLX classifieds in Poland, Ukraine, Romania, Bulgaria, and Portugal. Search listings by keyword, category, location, and price. Get ad details with descriptions, GPS, and photos, and reveal seller phone numbers. $2 per 1,000 results.

- **URL**: https://apify.com/sourabhbgp/olx-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** E-commerce, Real estate, Jobs
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### OLX scraper: search listings, ad details, seller phones and photos

Scrape OLX classifieds by keyword, category, location, price, and condition. Get full ad details with descriptions, GPS, seller info, and photos, and reveal seller phone numbers where they are public.

**$2 per 1,000 results. Flat for every mode. No proxy or browser setup needed.**

Works across Poland, Ukraine, Romania, Bulgaria, and Portugal.

### Why this scraper?

- 💸 **Flat $2 per 1,000 results.** Same price for search and ad details. No monthly minimum, no per-run subscription.
- 📞 **Reveals seller phone numbers.** Pulls the real number on listings where the seller made it public, roughly a third of ads. Most OLX scrapers skip this entirely.
- ⚡ **Fast and stable.** Reads OLX's own public data feed, so no headless browser, no CAPTCHAs, no flaky page rendering.
- 🌍 **Five countries, one actor.** Poland, Ukraine, Romania, Bulgaria, and Portugal share the same fields and inputs.
- 🧭 **Real filters, verified.** Category, region, city, price range, condition, and sort actually narrow the results, not just accepted and ignored.
- 📍 **Rich records.** Every listing carries price, condition, description, GPS coordinates, seller type (private vs. business), and full-resolution photo URLs.
- 🧾 **You pay for rows, nothing else.** Billing equals the number of results in your dataset. Duplicates are charged once.

### What data can you extract?

<table>
  <tr><td>🏷️ Title</td><td>💰 Price + currency</td><td>🆕 Condition</td><td>📝 Description</td></tr>
  <tr><td>📍 City + region</td><td>🗺️ GPS lat/lon</td><td>👤 Seller name</td><td>🏢 Private vs. business</td></tr>
  <tr><td>📞 Phone number</td><td>💬 Chat enabled</td><td>🖼️ Photo URLs</td><td>⭐ Promoted flag</td></tr>
  <tr><td>📅 Posted + refreshed date</td><td>🗂️ Category</td><td>🔧 Item attributes</td><td>🔗 Listing URL</td></tr>
</table>

### Two modes

#### 🔎 Search

Find listings by keyword, category, region or city, price range, and condition, with sorting. Each result already includes the full description, GPS, seller, and photos, so no second request per ad.

```json
{
  "mode": "search",
  "market": "pl",
  "query": "iphone 13",
  "categoryId": 99,
  "priceMin": 800,
  "priceMax": 2000,
  "condition": "used",
  "sortBy": "price_asc",
  "includePhone": true,
  "maxItems": 200
}
````

#### 📄 Detail

Fetch specific listings by URL or numeric ID. Paste OLX ad links or IDs straight in.

```json
{
  "mode": "detail",
  "market": "pl",
  "offerUrls": [
    "https://www.olx.pl/d/oferta/iphone-13-128gb-CID99-ID1bq7Mh.html",
    "1084898957"
  ],
  "includePhone": true
}
```

### How to scrape OLX: step by step

1. [Create a free Apify account](https://console.apify.com/sign-up). Takes 30 seconds, no card needed.
2. Open [OLX Scraper](https://console.apify.com/actors/6cKUOaevYRtdX62u5?addFromActorId=6cKUOaevYRtdX62u5) in the Apify Console.
3. Pick a market, then enter a search query and filters, or paste ad URLs for detail mode.
4. Click **Start**. Most runs finish in under a minute.
5. Export as JSON, CSV, or Excel, or pull the results via API.

### How much does OLX Scraper cost?

Pay per result: **$2.00 for 1,000 results**, the same for search and detail. The Apify Free plan includes $5 in monthly credits, roughly **2,499 results**. The $29/month Starter plan covers about **14,499 results** a month. There is a small one-time run-start fee of about $0.01, and no subscription lock-in.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | string | `search` | `search` or `detail` |
| `market` | string | `pl` | `pl`, `ua`, `ro`, `bg`, `pt` |
| `query` | string | | Free-text keyword (search mode) |
| `categoryId` | integer | | Numeric OLX category id |
| `regionId` | integer | | Numeric region id |
| `cityId` | integer | | Numeric city id |
| `priceMin` / `priceMax` | integer | | Price range in local currency |
| `condition` | string | `any` | `any`, `new`, `used` |
| `sortBy` | string | `relevance` | `relevance`, `created_desc`, `price_asc`, `price_desc` |
| `offerUrls` | array | | Ad URLs or numeric IDs (detail mode) |
| `includePhone` | boolean | `false` | Reveal seller phone numbers where public |
| `maxItems` | integer | `100` | Stop after this many results. `0` = no limit |

Search mode needs at least one of `query`, `categoryId`, `regionId`, or `cityId`.

### Output

Each result is one flat record. Search example (Poland):

```json
{
  "id": 1084898957,
  "url": "https://www.olx.pl/d/oferta/iphone-13-128gb-CID99-ID1bq7Mh.html",
  "title": "iPhone 13 128GB",
  "description": "iPhone 13 w bardzo dobrym stanie, bateria 89%...",
  "price": 1399,
  "priceLabel": "1 399 zł",
  "currency": "PLN",
  "negotiable": false,
  "condition": "used",
  "createdTime": "2026-07-11T19:02:49+02:00",
  "lastRefreshTime": "2026-07-12T16:14:25+02:00",
  "categoryId": 2298,
  "categoryType": "electronics",
  "city": "Kraków",
  "region": "Małopolskie",
  "lat": 50.06026,
  "lon": 19.94021,
  "sellerId": 88213344,
  "sellerName": "Anastazja",
  "sellerType": "private",
  "isBusiness": false,
  "companyName": null,
  "sellerLastSeen": "2026-07-12T17:11:51+02:00",
  "hasPhone": true,
  "chatEnabled": true,
  "phones": ["501 509 597"],
  "promoted": false,
  "photos": ["https://ireland.apollo.olxcdn.com/v1/files/lnprby3eddq21-PL/image;s=720x960"],
  "photoCount": 5,
  "params": { "state": "Używane", "phonemodel": "iPhone 13", "builtinmemory_phones": "128GB" },
  "market": "pl"
}
```

Detail mode returns the same shape. When `includePhone` is off, `phones` is `null`.

### Use cases

- 🛒 **Price research**: Track asking prices for a product, brand, or model across a whole country.
- 🚗 **Car and property market data**: Pull mileage, year, area, rooms, and location from vehicle and real-estate listings at scale.
- 🧲 **Lead generation**: Collect business sellers with phone numbers for outreach in a category or region.
- 📈 **Reseller sourcing**: Spot underpriced listings the moment they appear, sorted by newest or cheapest.
- 🔍 **Competitor monitoring**: Watch a shop's or dealer's active listings and how they change over time.
- 🗺️ **Local market analysis**: Map supply and pricing by city or region using per-listing GPS.

### Limitations

- **Browse depth per query is capped.** OLX limits paging on a single query to roughly 2,300 results. To pull more, split the search by category, region, or price band. The run reports a clear partial status when it hits the cap.
- **Phone numbers only where public.** Numbers appear on about a third of listings. Chat-only sellers withhold the number from everyone, so those rows have no phone.
- **No price on some ads.** "Ask for price" listings and job posts have no numeric price; the field is `null`.
- **Public data only.** The actor reads what any logged-out visitor can see. No private messages, no account-gated data.
- **Brazil not included.** OLX Brazil runs on a different platform and is not covered in this version.

### FAQ

#### How much does OLX Scraper cost?

OLX Scraper uses pay-per-result pricing. You pay **$2.00 for 1,000 results**. The Apify Free plan gives you $5 in usage credits a month, enough for around 2,499 results. If you run regularly, the $29/month Starter plan covers about 14,499 results.

No subscription lock-in. Pause whenever.

#### Is it legal to scrape OLX?

Scraping public data is generally allowed in the US and most of the EU, as long as you don't collect personal data covered by GDPR or CCPA without a lawful basis. This actor only touches publicly accessible pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate OLX Scraper with other tools?

Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use OLX Scraper with the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~olx-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "search", "market": "pl", "query": "iphone", "maxItems": 100}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use OLX Scraper through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call OLX Scraper. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/6cKUOaevYRtdX62u5/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

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

search: find offers by keyword, category, location and price. detail: fetch specific offers by URL or ID.

## `market` (type: `string`):

OLX country site to scrape. All share the same data.

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

Free-text keyword to search for (search mode). Leave empty to browse a whole category or location.

## `categoryId` (type: `integer`):

Numeric OLX category id to restrict to (optional). Find it in an offer's category.id or via a category page URL.

## `regionId` (type: `integer`):

Numeric region (voivodeship / county) id to restrict to (optional).

## `cityId` (type: `integer`):

Numeric city id to restrict to (optional). Requires or complements Region ID.

## `priceMin` (type: `integer`):

Minimum price in the market's local currency (optional).

## `priceMax` (type: `integer`):

Maximum price in the market's local currency (optional).

## `condition` (type: `string`):

Filter by item condition (search mode).

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

Result ordering (search mode).

## `offerUrls` (type: `array`):

Detail mode: OLX offer URLs (https://www.olx.pl/d/oferta/...) or bare numeric offer IDs.

## `includePhone` (type: `boolean`):

Fetch the seller's phone number for each offer where it is public (adds one request per offer; numbers are unavailable on chat-only offers).

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

Stop after this many offers. 0 = no limit (search will page until OLX's browse ceiling; slice by filter to go deeper).

## Actor input object example

```json
{
  "mode": "search",
  "market": "pl",
  "query": "iphone",
  "condition": "any",
  "sortBy": "relevance",
  "offerUrls": [
    "https://www.olx.pl/d/oferta/apple-iphone-11-mietowy-CID99-ID1bq0tU.html"
  ],
  "includePhone": false,
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

View the scraped offers in the dataset.

# 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": "iphone",
    "offerUrls": [
        "https://www.olx.pl/d/oferta/apple-iphone-11-mietowy-CID99-ID1bq0tU.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourabhbgp/olx-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": "iphone",
    "offerUrls": ["https://www.olx.pl/d/oferta/apple-iphone-11-mietowy-CID99-ID1bq0tU.html"],
}

# Run the Actor and wait for it to finish
run = client.actor("sourabhbgp/olx-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": "iphone",
  "offerUrls": [
    "https://www.olx.pl/d/oferta/apple-iphone-11-mietowy-CID99-ID1bq0tU.html"
  ]
}' |
apify call sourabhbgp/olx-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Scraper - Listings, Ad Details, Phone Numbers",
        "description": "Scrape OLX classifieds in Poland, Ukraine, Romania, Bulgaria, and Portugal. Search listings by keyword, category, location, and price. Get ad details with descriptions, GPS, and photos, and reveal seller phone numbers. $2 per 1,000 results.",
        "version": "0.0",
        "x-build-id": "ee32Sy5XEECPIj4aF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~olx-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-olx-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/sourabhbgp~olx-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-olx-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/sourabhbgp~olx-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-olx-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",
                    "market"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "detail"
                        ],
                        "type": "string",
                        "description": "search: find offers by keyword, category, location and price. detail: fetch specific offers by URL or ID.",
                        "default": "search"
                    },
                    "market": {
                        "title": "Market (country)",
                        "enum": [
                            "pl",
                            "ua",
                            "ro",
                            "bg",
                            "pt"
                        ],
                        "type": "string",
                        "description": "OLX country site to scrape. All share the same data.",
                        "default": "pl"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword to search for (search mode). Leave empty to browse a whole category or location."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Numeric OLX category id to restrict to (optional). Find it in an offer's category.id or via a category page URL."
                    },
                    "regionId": {
                        "title": "Region ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Numeric region (voivodeship / county) id to restrict to (optional)."
                    },
                    "cityId": {
                        "title": "City ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Numeric city id to restrict to (optional). Requires or complements Region ID."
                    },
                    "priceMin": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in the market's local currency (optional)."
                    },
                    "priceMax": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in the market's local currency (optional)."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "any",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter by item condition (search mode).",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "created_desc",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Result ordering (search mode).",
                        "default": "relevance"
                    },
                    "offerUrls": {
                        "title": "Offer URLs or IDs",
                        "type": "array",
                        "description": "Detail mode: OLX offer URLs (https://www.olx.pl/d/oferta/...) or bare numeric offer IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePhone": {
                        "title": "Reveal phone numbers",
                        "type": "boolean",
                        "description": "Fetch the seller's phone number for each offer where it is public (adds one request per offer; numbers are unavailable on chat-only offers).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many offers. 0 = no limit (search will page until OLX's browse ceiling; slice by filter to go deeper).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
