# OLX Global $1💰 All in One URL | Search | Listings Data (`abotapi/olx-scraper`) Actor

From $1/1K. Fast OLX scraper across 9 countries, including Poland, Romania, Portugal, Ukraine, Bulgaria, Kazakhstan, Uzbekistan, India, and Brazil. Extract structured listing data via search or URL with support for pagination and multi-market coverage.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## OLX Scraper

Fast scraper for OLX classifieds across **9 countries**: Poland (olx.pl), Romania (olx.ro), Portugal (olx.pt), Ukraine (olx.ua), Bulgaria (olx.bg), Kazakhstan (olx.kz), Uzbekistan (olx.uz), India (olx.in), and Brazil (olx.com.br). Built for low cost on the free tier (Brazil needs the Residential proxy add-on).

### Two modes

1. **Search by filters** - pick a country, then optionally narrow by category, city, query keyword, price range, and sort. The actor builds the request and walks pagination.
2. **Direct URLs** - paste one or more OLX search-result URLs. Country is auto-detected per URL. Each URL is paginated forward until your page or listings cap.

### What you get per listing

45+ fields, far richer than a typical OLX scraper:

- **Identity** - listing ID, country, URL, title, full description, status
- **Timeline** - created at, first posted at, last bumped at, listing expiry, display date
- **Price** - numeric value, ISO 4217 currency, formatted display, negotiable flag
- **Category** - ID, name, breadcrumb path
- **Location** - city, region, district, full display string, latitude, longitude, map zoom hint
- **Seller** - ID, UUID, display name, type (private/business/dealer), tag (e.g. "Approved dealer"), logo URL, account-created date, last login, KYC verified flag
- **Contact toggles** (boolean only - no PII) - phone available, chat available, negotiation, courier delivery, anonymized phone
- **Commercial** - business flag, partner code, shop ID, delivery options, safedeal escrow info
- **Media** - full image URL list, image count, video URLs
- **Attributes** - every parameter key/value (model, fuel, year, etc.), highlighted "key" parameters, value-added-service tags
- **Metadata** - promoted flag, relevance score (India), source search URL, scrape timestamp

Set `Fetch full details per listing` to add an enrichment pass that fills in any field that the search response omits (full description, seller account info, complete attribute list).

### Search filters

| Field | Applies to |
|---|---|
| Country | All |
| Free-text query | All |
| Category ID | All |
| City ID | Classic countries (PL/RO/PT/UA/BG/KZ/UZ) |
| Location ID | India |
| State subdomain | Brazil (auto-detected from URL) |
| Min / max price | All |
| Sort order | All |
| Extra filters (JSON passthrough) | Advanced |

The **Extra filters** field is an escape hatch for site-specific filters not exposed in the UI. Keys are passed verbatim into the request URL. Examples for classic countries:

```json
{ "filter_enum_make": ["bmw"], "filter_enum_fuel": ["diesel"], "filter_float_year:from": 2018 }
````

### URL mode notes

- Country is auto-detected from each URL's hostname.
- Pagination uses `?page=N` (classic countries), page-index (India), or `?o=N` (Brazil).
- Filter fields above are ignored - paste the URL with your filters already applied.
- Multi-URL is supported; each URL is processed sequentially.
- For Brazil URLs, the proxy must be Apify Residential country=BR (see Limits below).

### Output preview

Open the dataset and switch the **Overview** view to see the headline columns. **Seller info** and **Media** views give focused slices.

### Limits

- Classic countries cap server-side at offset 1000. Narrow your filters to scrape the full set on high-volume queries.
- Detail enrichment adds 1 extra HTTP call per listing. Off by default to keep cheap runs cheap.
- The default **Apify Datacenter** proxy works on the free tier and is sufficient for most countries. Switch to **Residential** if you hit rate limits on a high-traffic country.
- **Brazil requires Apify Residential proxy (country=BR)** - the Apify Datacenter pool is challenged by the upstream edge, so runs on Datacenter return zero listings. Set the proxy field to `Apify Residential` with country `BR` before running. The actor logs a clear warning if you start a BR run on Datacenter.

### Country support

| Country | TLD | API | Proxy |
|---|---|---|---|
| Poland | olx.pl | classic | Datacenter or Residential |
| Romania | olx.ro | classic | Datacenter or Residential |
| Portugal | olx.pt | classic | Datacenter or Residential |
| Ukraine | olx.ua | classic | Datacenter or Residential |
| Bulgaria | olx.bg | classic | Datacenter or Residential |
| Kazakhstan | olx.kz | classic | Datacenter or Residential |
| Uzbekistan | olx.uz | classic | Datacenter or Residential |
| India | olx.in | India relevance | Datacenter or Residential |
| Brazil | olx.com.br | Brazil SSR | **Residential country=BR required** |

OLX South Africa (olx.co.za) was decommissioned by the operator. OLX Egypt is now Dubizzle. OLX Argentina runs on a different platform and is not yet supported.

### Output schema

See the **dataset preview** in the Apify Console for the full field list and data types.

# Actor input Schema

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

Choose how to find listings. Only fields belonging to the chosen mode are used.

## `urls` (type: `array`):

OLX search-result URLs to scrape. Each URL auto-paginates forward until Maximum Pages or Maximum Listings is reached. Country is auto-detected from each URL. Ignored in Search mode. Example: https://www.olx.pl/motoryzacja/samochody/bmw/?search%5Bfilter\_float\_price%3Afrom%5D=10000

## `country` (type: `string`):

Country to search. Each country runs on the local OLX site (olx.pl, olx.ro, etc.). India runs on a separate API endpoint with the same output schema. (Search mode only — ignored in URL mode.)

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

Free-text search keyword (e.g. "BMW X5", "iPhone 15", "apartment Warsaw"). Combined with category and city filters when present. Leave empty to browse a category without keyword filtering.

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

OLX numeric category ID. Optional. Examples (Poland): 1605=Apartments, 5=Auto parts, 84 (India)=Cars. To find a category ID, browse OLX, open the category page, and look at the URL or the metadata.

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

Numeric city ID for filtering by city (PL, RO, PT, UA, BG, KZ, UZ). Look up city IDs by inspecting an OLX search URL after picking a city. Ignored for India (use locationId instead).

## `locationId` (type: `integer`):

Numeric location ID for olx.in (state/city). Example: 2001173=Tamil Nadu. Ignored for non-India searches.

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

Lower bound for price (in the country's local currency). Optional.

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

Upper bound for price (in the country's local currency). Optional.

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

How to order results. Default uses the country's relevance ranking.

## `extraFilters` (type: `object`):

Optional escape hatch for site-specific filters not exposed above. Keys are passed verbatim into the request URL. Examples (Pattern A countries): {"filter\_enum\_make": \["bmw"], "filter\_enum\_fuel": \["diesel"], "filter\_float\_year:from": 2018}. Use sparingly; keys are not validated.

## `fetchDetails` (type: `boolean`):

Fetch each listing's detail endpoint for the freshest revision, complete description, and full attribute list. Adds 1 extra HTTP call per listing.

## `maxListings` (type: `integer`):

Stop after scraping this many listings across the whole run. 0 = unlimited (capped only by maxPages).

## `maxPages` (type: `integer`):

Per-search page cap. Each page returns ~10 (Pattern A) or ~40 (India) listings. Pattern A countries cap server-side at offset 1000 — narrow your filters to see further.

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

Default Apify Datacenter works on the free tier and is sufficient for 8 of 9 countries (PL, RO, PT, UA, BG, KZ, UZ, IN). For Brazil (olx.com.br) you MUST switch the proxy field to Apify Residential with country=BR — the upstream edge rejects datacenter IPs there. Residential also helps if you hit transient rate limits on a high-traffic country. Custom proxy URLs are accepted as well.

## Actor input object example

```json
{
  "mode": "search",
  "urls": [
    "https://www.olx.pl/motoryzacja/samochody/bmw/"
  ],
  "country": "pl",
  "sortBy": "default",
  "fetchDetails": false,
  "maxListings": 20,
  "maxPages": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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",
    "urls": [
        "https://www.olx.pl/motoryzacja/samochody/bmw/"
    ],
    "country": "pl",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "mode": "search",
    "urls": ["https://www.olx.pl/motoryzacja/samochody/bmw/"],
    "country": "pl",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "mode": "search",
  "urls": [
    "https://www.olx.pl/motoryzacja/samochody/bmw/"
  ],
  "country": "pl",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/olx-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Global $1💰 All in One URL | Search | Listings Data",
        "description": "From $1/1K. Fast OLX scraper across 9 countries, including Poland, Romania, Portugal, Ukraine, Bulgaria, Kazakhstan, Uzbekistan, India, and Brazil. Extract structured listing data via search or URL with support for pagination and multi-market coverage.",
        "version": "1.0",
        "x-build-id": "a1Qe9s36YqFBAFDvh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~olx-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-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/abotapi~olx-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-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/abotapi~olx-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-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"
                ],
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Choose how to find listings. Only fields belonging to the chosen mode are used.",
                        "default": "search"
                    },
                    "urls": {
                        "title": "URLs (URL mode only)",
                        "type": "array",
                        "description": "OLX search-result URLs to scrape. Each URL auto-paginates forward until Maximum Pages or Maximum Listings is reached. Country is auto-detected from each URL. Ignored in Search mode. Example: https://www.olx.pl/motoryzacja/samochody/bmw/?search%5Bfilter_float_price%3Afrom%5D=10000",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "pl",
                            "ro",
                            "pt",
                            "ua",
                            "bg",
                            "kz",
                            "uz",
                            "in",
                            "br"
                        ],
                        "type": "string",
                        "description": "Country to search. Each country runs on the local OLX site (olx.pl, olx.ro, etc.). India runs on a separate API endpoint with the same output schema. (Search mode only — ignored in URL mode.)",
                        "default": "pl"
                    },
                    "query": {
                        "title": "Search query (free text)",
                        "type": "string",
                        "description": "Free-text search keyword (e.g. \"BMW X5\", \"iPhone 15\", \"apartment Warsaw\"). Combined with category and city filters when present. Leave empty to browse a category without keyword filtering."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "OLX numeric category ID. Optional. Examples (Poland): 1605=Apartments, 5=Auto parts, 84 (India)=Cars. To find a category ID, browse OLX, open the category page, and look at the URL or the metadata."
                    },
                    "cityId": {
                        "title": "City ID (Pattern A only)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Numeric city ID for filtering by city (PL, RO, PT, UA, BG, KZ, UZ). Look up city IDs by inspecting an OLX search URL after picking a city. Ignored for India (use locationId instead)."
                    },
                    "locationId": {
                        "title": "Location ID (India only)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Numeric location ID for olx.in (state/city). Example: 2001173=Tamil Nadu. Ignored for non-India searches."
                    },
                    "priceMin": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound for price (in the country's local currency). Optional."
                    },
                    "priceMax": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound for price (in the country's local currency). Optional."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "default",
                            "created_desc",
                            "created_asc",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "How to order results. Default uses the country's relevance ranking.",
                        "default": "default"
                    },
                    "extraFilters": {
                        "title": "Extra filters (advanced passthrough)",
                        "type": "object",
                        "description": "Optional escape hatch for site-specific filters not exposed above. Keys are passed verbatim into the request URL. Examples (Pattern A countries): {\"filter_enum_make\": [\"bmw\"], \"filter_enum_fuel\": [\"diesel\"], \"filter_float_year:from\": 2018}. Use sparingly; keys are not validated."
                    },
                    "fetchDetails": {
                        "title": "Fetch full details per listing",
                        "type": "boolean",
                        "description": "Fetch each listing's detail endpoint for the freshest revision, complete description, and full attribute list. Adds 1 extra HTTP call per listing.",
                        "default": false
                    },
                    "maxListings": {
                        "title": "Maximum listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after scraping this many listings across the whole run. 0 = unlimited (capped only by maxPages).",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Per-search page cap. Each page returns ~10 (Pattern A) or ~40 (India) listings. Pattern A countries cap server-side at offset 1000 — narrow your filters to see further.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Default Apify Datacenter works on the free tier and is sufficient for 8 of 9 countries (PL, RO, PT, UA, BG, KZ, UZ, IN). For Brazil (olx.com.br) you MUST switch the proxy field to Apify Residential with country=BR — the upstream edge rejects datacenter IPs there. Residential also helps if you hit transient rate limits on a high-traffic country. Custom proxy URLs are accepted as well."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
