# OLX Kazakhstan Classifieds Scraper (`automation-lab/olx-kazakhstan-classifieds-scraper`) Actor

Extract OLX.kz listings with prices, locations, seller signals, images, attributes, timestamps, and URLs for Kazakhstan market research.

- **URL**: https://apify.com/automation-lab/olx-kazakhstan-classifieds-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.
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 Kazakhstan Classifieds Scraper

Extract public classified ads from OLX.kz search and category pages.

Use this actor to monitor Kazakhstan marketplace inventory, prices, seller signals, listing attributes, images, and listing freshness without building your own scraper.

OLX Kazakhstan Classifieds Scraper is designed for public marketplace pages such as cars, electronics, real estate, jobs, services, and keyword searches.

It uses fast HTTP extraction from OLX.kz prerendered page data, so most runs are lightweight and do not need a browser.

### What does OLX Kazakhstan Classifieds Scraper do?

The actor scrapes OLX.kz listing result pages and saves structured listing records.

It can start from OLX category URLs, OLX search URLs, or keyword searches.

For each listing, it extracts core marketplace data such as title, price, location, URL, seller name, images, public contact flags, attributes, and timestamps.

It is useful when you need a repeatable export of public OLX.kz marketplace data for analysis, alerts, or enrichment workflows.

### Who is it for?

#### Ecommerce analysts

Track consumer-to-consumer prices across electronics, vehicles, furniture, and other categories.

#### Automotive market teams

Monitor used car inventory, price ranges, seller types, locations, and listing refresh behavior.

#### Real estate researchers

Collect public rental and sale listings by city, neighborhood, and property attributes.

#### Lead generation teams

Find public listings that match sourcing, resale, or outreach criteria.

#### Data teams

Create repeatable OLX.kz datasets for dashboards, notebooks, BI pipelines, and machine learning features.

### Why use this actor?

- ⚡ HTTP-only extraction for fast runs
- 🇰🇿 Built specifically for OLX Kazakhstan
- 🧾 Exports prices, locations, attributes, images, and seller signals
- 🔁 Supports category URLs and keyword searches
- 📦 Pay per extracted listing
- 🧩 Works with Apify datasets, API, integrations, and MCP

### What OLX.kz data can you extract?

| Field | Description |
| --- | --- |
| `id` | OLX listing identifier |
| `title` | Listing title |
| `url` | Canonical OLX.kz listing URL |
| `price` | Numeric price when available |
| `priceDisplay` | Human-readable price text |
| `currency` | Currency code such as KZT |
| `negotiable` | Whether the listed price is negotiable |
| `location` | OLX location path |
| `city` | City name |
| `region` | Region name |
| `description` | HTML-stripped public description |
| `imageUrls` | Public listing image URLs |
| `sellerName` | Public seller/contact name |
| `isBusiness` | Public business seller flag |
| `hasPhone` | Whether OLX exposes phone contact availability |
| `hasChat` | Whether chat is available |
| `attributes` | Category-specific specs such as model, condition, fuel, or size |
| `createdTime` | Listing creation timestamp |
| `lastRefreshTime` | Last refresh timestamp |
| `sourceUrl` | Page where the listing was found |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape OLX Kazakhstan listings?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-listing fee for each saved listing.

The current pricing is $0.005 per run start plus tiered per-listing pricing. BRONZE users pay $0.001 per listing, with FREE at $0.00115 and higher tiers discounted down to $0.00028 for DIAMOND.

Example cost pattern:

- A small 20-listing test run is inexpensive and good for validating inputs.
- A 100-listing category run is better for price monitoring.
- A larger scheduled run can power dashboards or alerts.

### How to scrape OLX Kazakhstan in 5 steps

1. Open the actor on Apify.
2. Add one or more OLX.kz category or search URLs.
3. Optionally add keyword searches such as `iphone` or `toyota camry`.
4. Set `maxItems` to the number of listings you need.
5. Run the actor and download the dataset as JSON, CSV, Excel, XML, or via API.

### Input parameters

#### `startUrls`

OLX.kz category or search URLs.

Example:

```json
[
  { "url": "https://www.olx.kz/d/transport/legkovye-avtomobili/" }
]
````

#### `searchQueries`

Keyword searches to run on OLX.kz.

Example:

```json
["iphone", "toyota camry"]
```

#### `maxItems`

Maximum listings to save across all sources.

Start low for testing.

Increase it for production exports.

#### `includeDescriptions`

Set to `true` to include HTML-stripped listing descriptions.

Set to `false` if you only need compact listing summaries.

#### `maxPagesPerSource`

Maximum OLX result pages to crawl per input URL or keyword.

#### `proxyConfiguration`

Optional proxy settings.

OLX.kz usually works with direct HTTP extraction.

Enable Apify Proxy only if your environment is blocked.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.olx.kz/d/transport/legkovye-avtomobili/" }
  ],
  "searchQueries": ["iphone"],
  "maxItems": 20,
  "includeDescriptions": true,
  "maxPagesPerSource": 2
}
```

### Example output

```json
{
  "id": "396458279",
  "title": "Chevrolet Epica 2.0 автомат",
  "url": "https://www.olx.kz/d/obyavlenie/example.html",
  "price": 3000000,
  "priceDisplay": "3 000 000 тг.",
  "currency": "KZT",
  "location": "Актюбинская область, Хромтау",
  "city": "Хромтау",
  "region": "Актюбинская область",
  "sellerName": "seller",
  "hasPhone": true,
  "hasChat": true,
  "attributes": {
    "Модель": "Epica",
    "Год выпуска": "2007"
  },
  "sourceUrl": "https://www.olx.kz/d/transport/legkovye-avtomobili/",
  "scrapedAt": "2026-05-19T08:00:00.000Z"
}
```

### Tips for better results

- ✅ Use specific category URLs when you already know the OLX section.
- ✅ Use keyword searches for discovery across categories.
- ✅ Keep `maxItems` small for test runs.
- ✅ Schedule recurring runs for price monitoring.
- ✅ Export to CSV for spreadsheet analysis.
- ✅ Use `sourceUrl` to separate multiple input sources.

### Common OLX Kazakhstan use cases

#### Vehicle price tracking

Monitor used car prices, locations, model attributes, and seller behavior.

#### Electronics monitoring

Track phones, laptops, consoles, and accessories by keyword.

#### Real estate research

Collect public listing summaries for rentals and property sale categories.

#### Inventory sourcing

Find public marketplace listings matching resale criteria.

#### Market intelligence

Analyze supply, pricing, refresh cadence, and regional availability.

### Integrations

Use Apify integrations to send OLX.kz data into your existing workflow.

- Google Sheets for manual review
- Slack or email alerts for new listings
- Make or Zapier for no-code automations
- Webhooks for event-driven pipelines
- BigQuery, Snowflake, or S3 for analytics storage

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/olx-kazakhstan-classifieds-scraper').call({
  startUrls: [{ url: 'https://www.olx.kz/d/transport/legkovye-avtomobili/' }],
  maxItems: 20
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/olx-kazakhstan-classifieds-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.olx.kz/d/transport/legkovye-avtomobili/'}],
    'maxItems': 20,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~olx-kazakhstan-classifieds-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.olx.kz/d/transport/legkovye-avtomobili/"}],"maxItems":20}'
```

### MCP usage

Connect this actor to AI tools through Apify MCP.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/olx-kazakhstan-classifieds-scraper"
```

#### Claude Desktop, Cursor, and VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/olx-kazakhstan-classifieds-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 50 OLX Kazakhstan used car listings and summarize price ranges by city."
- "Find OLX.kz iPhone listings and group them by listed price."
- "Collect public OLX.kz real estate listings from this category URL."

### Data quality notes

OLX categories differ in the attributes they expose.

Vehicle listings may include model, body type, fuel, and year.

Real estate listings may include rooms, size, floor, or property condition.

Electronics listings may include condition and model information.

All such details are stored in the `attributes` object.

### Limitations

The actor extracts public listing data available in OLX.kz page HTML.

It does not log in.

It does not bypass private user settings.

It does not reveal hidden phone numbers.

It does not scrape messages or private account data.

### Troubleshooting

#### Why did I get fewer listings than requested?

The selected category or search may have fewer available public results than your `maxItems`, or `maxPagesPerSource` may be too low.

Increase `maxPagesPerSource` or use broader input URLs.

#### Why are some prices empty?

Some OLX listings may be marked as negotiable, exchange, free, or otherwise not provide a numeric regular price.

Use `priceDisplay` for the user-facing price text.

#### Should I enable proxies?

Usually no.

The actor is HTTP-only and OLX.kz public pages often return the needed data directly.

Enable proxy settings only if your run is blocked.

### Legality and responsible use

This actor extracts publicly available OLX.kz listing data.

You are responsible for using the data in accordance with applicable laws, OLX terms, and privacy rules.

Do not use scraped data for spam, harassment, or unlawful profiling.

Respect robots, rate limits, and data protection obligations in your jurisdiction.

### Related scrapers

Explore other Automation Lab actors for marketplace and ecommerce workflows:

- https://apify.com/automation-lab/amazon-scraper
- https://apify.com/automation-lab/ebay-scraper
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/google-maps-lead-finder

### FAQ

#### Can I scrape any OLX.kz category?

Yes, use a public OLX.kz category or search URL as a start URL.

#### Can I run keyword searches?

Yes, add values to `searchQueries`.

#### Does it support pagination?

Yes, it follows OLX page numbers up to `maxPagesPerSource` or until `maxItems` is reached.

#### Does it scrape listing detail pages?

The MVP extracts detailed fields embedded in search/category pages. That already includes description, attributes, image URLs, seller snippets, and timestamps for many listings.

#### Does it use a browser?

No. It uses HTTP extraction from prerendered OLX page data for speed and lower cost.

#### Can I schedule it?

Yes. Use Apify schedules to monitor OLX.kz categories or searches daily, hourly, or at another cadence.

#### Can I export CSV?

Yes. Apify datasets support CSV, JSON, JSONL, Excel, XML, RSS, and API access.

#### What language are the results in?

Results are returned as OLX.kz provides them, commonly Russian and Kazakh depending on the listing.

# Actor input Schema

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

OLX.kz search or category URLs to crawl, for example a cars, real estate, jobs, or electronics category page.

## `searchQueries` (type: `array`):

Optional OLX.kz keyword searches. Each query becomes an OLX search URL such as /list/q-iphone/.

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

Maximum number of OLX.kz listings to save across all URLs and keyword searches.

## `includeDescriptions` (type: `boolean`):

Include HTML-stripped listing descriptions from OLX embedded page data.

## `maxPagesPerSource` (type: `integer`):

Maximum OLX result pages to crawl for each start URL or keyword search.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed OLX.kz HTTP requests.

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

Optional Apify Proxy settings. OLX.kz pages usually work over direct HTTP; enable proxy only if your runs are blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.olx.kz/d/transport/legkovye-avtomobili/"
    }
  ],
  "searchQueries": [
    "iphone"
  ],
  "maxItems": 20,
  "includeDescriptions": true,
  "maxPagesPerSource": 2,
  "maxRequestRetries": 3
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.olx.kz/d/transport/legkovye-avtomobili/"
        }
    ],
    "searchQueries": [
        "iphone"
    ],
    "maxItems": 20,
    "includeDescriptions": true,
    "maxPagesPerSource": 2,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/olx-kazakhstan-classifieds-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.olx.kz/d/transport/legkovye-avtomobili/" }],
    "searchQueries": ["iphone"],
    "maxItems": 20,
    "includeDescriptions": True,
    "maxPagesPerSource": 2,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/olx-kazakhstan-classifieds-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.olx.kz/d/transport/legkovye-avtomobili/"
    }
  ],
  "searchQueries": [
    "iphone"
  ],
  "maxItems": 20,
  "includeDescriptions": true,
  "maxPagesPerSource": 2,
  "maxRequestRetries": 3
}' |
apify call automation-lab/olx-kazakhstan-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Kazakhstan Classifieds Scraper",
        "description": "Extract OLX.kz listings with prices, locations, seller signals, images, attributes, timestamps, and URLs for Kazakhstan market research.",
        "version": "0.1",
        "x-build-id": "anYJVlEXnplZVTwM9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~olx-kazakhstan-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-olx-kazakhstan-classifieds-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/automation-lab~olx-kazakhstan-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-olx-kazakhstan-classifieds-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/automation-lab~olx-kazakhstan-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-olx-kazakhstan-classifieds-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",
                "properties": {
                    "startUrls": {
                        "title": "🔗 OLX.kz start URLs",
                        "type": "array",
                        "description": "OLX.kz search or category URLs to crawl, for example a cars, real estate, jobs, or electronics category page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "🔎 Keyword searches",
                        "type": "array",
                        "description": "Optional OLX.kz keyword searches. Each query becomes an OLX search URL such as /list/q-iphone/.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "📦 Maximum listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of OLX.kz listings to save across all URLs and keyword searches.",
                        "default": 50
                    },
                    "includeDescriptions": {
                        "title": "📝 Include descriptions",
                        "type": "boolean",
                        "description": "Include HTML-stripped listing descriptions from OLX embedded page data.",
                        "default": true
                    },
                    "maxPagesPerSource": {
                        "title": "📄 Max pages per source",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum OLX result pages to crawl for each start URL or keyword search.",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "🔁 HTTP retry attempts",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed OLX.kz HTTP requests.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. OLX.kz pages usually work over direct HTTP; enable proxy only if your runs are blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
