# OLX Global Scraper (`crawlerbros/olx-global-scraper`) Actor

Scrape OLX classified-ad listings across 24 countries (Poland, Ukraine, Brazil, India, Pakistan, Indonesia, Argentina, Türkiye, Portugal, ...). Search by keyword, browse by category / city, fetch listing details, list seller ads, or accept any OLX URL.

- **URL**: https://apify.com/crawlerbros/olx-global-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 8 total users, 3 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## OLX Global Scraper

Scrape classified-ad listings from OLX across **24 countries** — Poland, Ukraine, Brazil, Romania, Bulgaria, India, Pakistan, Indonesia, Argentina, Colombia, Chile, Peru, Türkiye, South Africa, Kazakhstan, Uzbekistan, Morocco, Algeria, Tunisia, Lebanon, Jordan, Qatar, Portugal, Dominican Republic.

Search by keyword, browse by category or city, fetch single-listing detail pages, list a seller's ads, or paste any OLX URL.

### What you can do

- **Search listings** by free-text query in any of OLX's 24 country sites.
- **Browse a category** (cars, electronics, real estate, jobs, fashion, ...).
- **Browse a city / region** within a country (with optional keyword filter).
- **Fetch single listing details** — full description, all photos, breadcrumb category, seller name, price, location.
- **List a seller's listings** — every active ad on a user profile.
- **Paste any OLX URL** — listing, search, category, city, seller — and the actor classifies it automatically.

### Supported countries

| Code | Country | Domain | Currency |
|---|---|---|---|
| pl | Poland | olx.pl | PLN |
| ua | Ukraine | olx.ua | UAH |
| ro | Romania | olx.ro | RON |
| bg | Bulgaria | olx.bg | BGN |
| kz | Kazakhstan | olx.kz | KZT |
| uz | Uzbekistan | olx.uz | UZS |
| br | Brazil | olx.com.br | BRL |
| ar | Argentina | olx.com.ar | ARS |
| co | Colombia | olx.com.co | COP |
| cl | Chile | olx.cl | CLP |
| pe | Peru | olx.com.pe | PEN |
| do | Dominican Republic | olx.com.do | DOP |
| in | India | olx.in | INR |
| pk | Pakistan | olx.com.pk | PKR |
| id | Indonesia | olx.co.id | IDR |
| tr | Türkiye | olx.com.tr | TRY |
| za | South Africa | olx.co.za | ZAR |
| ma | Morocco | olx.ma | MAD |
| dz | Algeria | olx.dz | DZD |
| tn | Tunisia | olx.com.tn | TND |
| lb | Lebanon | olx.com.lb | LBP |
| jo | Jordan | olx.com.jo | JOD |
| qa | Qatar | olx.com.qa | QAR |
| pt | Portugal | olx.pt | EUR |

### Output fields

| Field | Type | Description |
|---|---|---|
| `listingId` | string | OLX listing ID. |
| `title` | string | Listing title. |
| `price` | integer | Numeric price in the country's local currency. |
| `priceText` | string | Original price string as shown on OLX (preserves "Free" / "Swap"). |
| `currency` | string | ISO-4217 currency code. |
| `description` | string | Full description (truncated at 30k chars on detail mode). |
| `category` | string | Top-level category from breadcrumb. |
| `subcategory` | string | Second-level category. |
| `breadcrumbs` | string[] | Full breadcrumb chain. |
| `city` | string | Listing's city / region. |
| `locationDate` | string | Combined location + posted-date string from card. |
| `postedAtText` | string | Posted-date string as shown ("Yesterday", "08 May 2026"). |
| `sellerName` | string | Seller display name. |
| `sellerUrl` | string | Seller profile URL. |
| `images` | string[] | All listing image URLs (detail mode). |
| `thumbnailUrl` | string | Primary image URL. |
| `listingUrl` | string | Canonical listing URL. |
| `country` | string | Two-letter country code. |
| `countryName` | string | Full country name. |
| `recordType` | string | Always `listing`. |
| `siteName` | string | `OLX`. |
| `scrapedAt` | string (ISO-8601) | |

### Modes & input

| Mode | What it does | Required input |
|---|---|---|
| `searchListings` | Free-text search on the chosen country site. | `country`, `query` |
| `byCategory` | Browse a top-level category. | `country`, `category` |
| `byCity` | Browse a city or region. | `country`, `city` (optionally `query`/`category`) |
| `byListing` | Fetch one or more listing detail pages. | `listingUrls` |
| `bySeller` | List all of a seller's listings. | `sellerUrl` |
| `byUrl` | Mix any OLX URLs across countries. | `urls` |

#### Filters

- `condition` — new / used / any.
- `priceMin`, `priceMax` — numeric, in the country's local currency.
- `fetchListingDetails` — for search/category/city modes, also fetch each listing's detail page (full description + all photos). Adds 1 HTTP request per listing.
- `maxItems` — hard cap (1–1000).
- `maxPages` — paginated listing pages (?page=N) to crawl per seed.
- `useProxy` / `proxyConfiguration` / `autoEscalateOnBlock` — proxy controls. Most countries work direct; Brazil and India auto-escalate to Apify proxy on a 403.

### Daily test prefill

`country=pl`, `mode=searchListings`, `query="laptop"`, `maxItems=10` — Poland is OLX's biggest market and always returns ≥10 listings.

### Reliability

- HTTP-only via `curl_cffi` (Chrome 131 fingerprint). No browser, no Playwright.
- Retries on 429/5xx with exponential backoff.
- Auto-escalates to Apify proxy on the first 403/429/Cloudflare challenge.
- Recursive omit-empty before every record push (no `null` / `""` / `[]` fields).

### FAQ

**Q: Some country sites return 403 from datacenter IPs — what do I do?**  
Enable `useProxy=true` (or rely on `autoEscalateOnBlock`, which is on by default). Brazil (olx.com.br) and India (olx.in) commonly need a residential proxy.

**Q: Does this work for OLX Russia?**  
No — OLX shut down `olx.ru` years ago.

**Q: Can I run multiple countries in one run?**  
Use `mode=byUrl` with URLs from different countries — the actor auto-detects the country per URL. Otherwise pick one country per run.

**Q: Are price values comparable across countries?**  
No — `price` is in the country's local currency (`currency` field). Convert externally if you need cross-country comparison.

**Q: Why don't I see seller phone numbers?**  
OLX hides phone numbers behind a click + captcha. Out of scope for this actor; consider it a separate concern.

**Q: `bySeller` returns 0 records — bug?**  
On most country sites, OLX renders the seller's listings client-side via JavaScript. The actor is HTTP-only, so it cannot execute that JS. Use `searchListings` with `query` + `fetchListingDetails=true`, then group records in your downstream pipeline by `sellerUrl`.

**Q: How is `category` filled?**  
On detail-mode records, from the page's breadcrumb. On card-mode records, the breadcrumb isn't rendered; enable `fetchListingDetails=true` if you need it on every listing.

# Actor input Schema

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

Which OLX country site to scrape. Selects the appropriate domain (olx.pl, olx.ua, ...) and currency.
## `mode` (type: `string`):

Which lookup axis to use.
## `query` (type: `string`):

Free-text search query.
## `category` (type: `string`):

Top-level category. OLX uses different country-specific slugs, so the actor maps these onto each domain. (any) = no category filter.
## `city` (type: `string`):

City slug as it appears in OLX URLs (e.g. 'warszawa', 'krakow', 'sao-paulo', 'mumbai'). Country-specific.
## `listingUrls` (type: `array`):

Direct OLX listing detail URLs. Country prefix is auto-detected from each URL.
## `sellerUrl` (type: `string`):

OLX seller / user profile URL (e.g. https://www.olx.pl/oferty/uzytkownik/abc123/).
## `urls` (type: `array`):

Any mix of OLX URLs across countries — listing pages, search pages, category pages, city pages, seller pages.
## `condition` (type: `string`):

Filter to new or used listings.
## `priceMin` (type: `integer`):

Drop listings below this price (in the country's local currency).
## `priceMax` (type: `integer`):

Drop listings above this price.
## `fetchListingDetails` (type: `boolean`):

For search / category / city modes, additionally fetch each listing's detail page for richer data (full description, all images, location, seller). Adds 1 HTTP request per listing.
## `maxItems` (type: `integer`):

Hard cap on emitted records.
## `maxPages` (type: `integer`):

Maximum paginated listing pages (?page=N) to crawl per seed URL. Each page returns ~52 listings on most OLX sites.
## `useProxy` (type: `boolean`):

Route HTTP requests through Apify proxy. Some OLX countries (e.g. Brazil, India) block datacenter IPs — enable this if direct fetches return 403.
## `autoEscalateOnBlock` (type: `boolean`):

If a 403 / Cloudflare challenge appears on a country site, automatically retry through the Apify proxy.
## `proxyConfiguration` (type: `object`):

Apify proxy configuration. Used when useProxy is enabled or auto-escalation triggers.

## Actor input object example

```json
{
  "country": "pl",
  "mode": "searchListings",
  "query": "laptop",
  "category": "",
  "city": "",
  "listingUrls": [],
  "sellerUrl": "",
  "urls": [],
  "condition": "",
  "fetchListingDetails": false,
  "maxItems": 10,
  "maxPages": 3,
  "useProxy": false,
  "autoEscalateOnBlock": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
````

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped OLX listings.

# 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 = {
    "country": "pl",
    "mode": "searchListings",
    "query": "laptop",
    "category": "",
    "city": "",
    "listingUrls": [],
    "sellerUrl": "",
    "urls": [],
    "condition": "",
    "fetchListingDetails": false,
    "maxItems": 10,
    "maxPages": 3,
    "useProxy": false,
    "autoEscalateOnBlock": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/olx-global-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 = {
    "country": "pl",
    "mode": "searchListings",
    "query": "laptop",
    "category": "",
    "city": "",
    "listingUrls": [],
    "sellerUrl": "",
    "urls": [],
    "condition": "",
    "fetchListingDetails": False,
    "maxItems": 10,
    "maxPages": 3,
    "useProxy": False,
    "autoEscalateOnBlock": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/olx-global-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 '{
  "country": "pl",
  "mode": "searchListings",
  "query": "laptop",
  "category": "",
  "city": "",
  "listingUrls": [],
  "sellerUrl": "",
  "urls": [],
  "condition": "",
  "fetchListingDetails": false,
  "maxItems": 10,
  "maxPages": 3,
  "useProxy": false,
  "autoEscalateOnBlock": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call crawlerbros/olx-global-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Global Scraper",
        "description": "Scrape OLX classified-ad listings across 24 countries (Poland, Ukraine, Brazil, India, Pakistan, Indonesia, Argentina, Türkiye, Portugal, ...). Search by keyword, browse by category / city, fetch listing details, list seller ads, or accept any OLX URL.",
        "version": "1.0",
        "x-build-id": "4fqxPynbZWosPN5Ne"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~olx-global-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-olx-global-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~olx-global-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-olx-global-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~olx-global-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-olx-global-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": [
                    "country",
                    "mode"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "pl",
                            "ua",
                            "ro",
                            "bg",
                            "kz",
                            "uz",
                            "br",
                            "ar",
                            "co",
                            "cl",
                            "pe",
                            "do",
                            "in",
                            "pk",
                            "id",
                            "tr",
                            "za",
                            "ma",
                            "dz",
                            "tn",
                            "lb",
                            "jo",
                            "qa",
                            "pt"
                        ],
                        "type": "string",
                        "description": "Which OLX country site to scrape. Selects the appropriate domain (olx.pl, olx.ua, ...) and currency.",
                        "default": "pl"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchListings",
                            "byCategory",
                            "byCity",
                            "byListing",
                            "bySeller",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "Which lookup axis to use.",
                        "default": "searchListings"
                    },
                    "query": {
                        "title": "Search query (mode=searchListings, byCity)",
                        "type": "string",
                        "description": "Free-text search query.",
                        "default": "laptop"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "",
                            "motoryzacja",
                            "nieruchomosci",
                            "praca",
                            "elektronika",
                            "moda",
                            "dom-i-ogrod",
                            "dla-dzieci",
                            "sport-hobby",
                            "muzyka-edukacja",
                            "zwierzeta",
                            "uslugi",
                            "rolnictwo",
                            "oddam-za-darmo"
                        ],
                        "type": "string",
                        "description": "Top-level category. OLX uses different country-specific slugs, so the actor maps these onto each domain. (any) = no category filter.",
                        "default": ""
                    },
                    "city": {
                        "title": "City slug (mode=byCity)",
                        "type": "string",
                        "description": "City slug as it appears in OLX URLs (e.g. 'warszawa', 'krakow', 'sao-paulo', 'mumbai'). Country-specific.",
                        "default": ""
                    },
                    "listingUrls": {
                        "title": "Listing URLs (mode=byListing)",
                        "type": "array",
                        "description": "Direct OLX listing detail URLs. Country prefix is auto-detected from each URL.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerUrl": {
                        "title": "Seller profile URL (mode=bySeller)",
                        "type": "string",
                        "description": "OLX seller / user profile URL (e.g. https://www.olx.pl/oferty/uzytkownik/abc123/).",
                        "default": ""
                    },
                    "urls": {
                        "title": "Mixed OLX URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Any mix of OLX URLs across countries — listing pages, search pages, category pages, city pages, seller pages.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "condition": {
                        "title": "Condition filter",
                        "enum": [
                            "",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter to new or used listings.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "Min price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop listings below this price (in the country's local currency)."
                    },
                    "priceMax": {
                        "title": "Max price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop listings above this price."
                    },
                    "fetchListingDetails": {
                        "title": "Fetch listing details",
                        "type": "boolean",
                        "description": "For search / category / city modes, additionally fetch each listing's detail page for richer data (full description, all images, location, seller). Adds 1 HTTP request per listing.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Max listing pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum paginated listing pages (?page=N) to crawl per seed URL. Each page returns ~52 listings on most OLX sites.",
                        "default": 3
                    },
                    "useProxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "Route HTTP requests through Apify proxy. Some OLX countries (e.g. Brazil, India) block datacenter IPs — enable this if direct fetches return 403.",
                        "default": false
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate on block",
                        "type": "boolean",
                        "description": "If a 403 / Cloudflare challenge appears on a country site, automatically retry through the Apify proxy.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Used when useProxy is enabled or auto-escalation triggers.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
