# Bazos Scraper - Czech & Slovak Classifieds Marketplace (`studio-amba/bazos-scraper`) Actor

Scrape classifieds listings from Bazos.cz and Bazos.sk. Extract prices, descriptions, seller info, images, and location data. No login required.

- **URL**: https://apify.com/studio-amba/bazos-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (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 usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Bazos Scraper - Czech & Slovak Classifieds Data

Extract classified listings, prices, seller information, and images from [Bazos.cz](https://www.bazos.cz) (Czech Republic) and [Bazos.sk](https://www.bazos.sk) (Slovakia) — the most popular peer-to-peer classifieds platform in Central Europe with millions of active listings across 20+ categories.

### How to scrape Bazos data

Bazos Scraper collects structured listing data from both the Czech and Slovak versions of Bazos. It searches by keyword, browses category pages, or scrapes individual listing URLs. The scraper handles pagination automatically and can visit each listing's detail page for full descriptions, seller contact info, and all images.

Bazos is famously minimal — no JavaScript rendering, no anti-bot protection, pure HTML. This makes it one of the fastest and cheapest sites to scrape on the Apify platform. The same simple structure has been running since 2004, serving over 3 million monthly visitors in the Czech Republic alone.

**No login or cookies required.**

**Popular use cases:**

- **Market research** — Monitor pricing trends for used electronics, vehicles, real estate, and consumer goods across Czech and Slovak markets.
- **Price comparison** — Track how much specific items (phones, laptops, cars) sell for on the peer-to-peer market vs. retail.
- **Lead generation** — Find sellers offering specific products or services in target regions.
- **Academic research** — Study classifieds market dynamics, regional pricing differences, and consumer behavior in Central European markets.
- **Inventory sourcing** — Discover bulk lots, business liquidations, and wholesale opportunities posted by sellers.

### What data does Bazos Scraper extract?

When `scrapeDetails` is enabled (default), each listing includes:

- **listingTitle** — Title of the classified listing
- **price** — Listed price (null for "Dohodou"/negotiable listings)
- **currency** — CZK for bazos.cz, EUR for bazos.sk
- **listingDescription** — Full description text from the detail page
- **sellerName** — Name of the seller
- **location** — Seller's city or area
- **postalCode** — Seller's postal code
- **datePosted** — Date the listing was published (ISO format)
- **imageUrl** — Primary listing image (full size)
- **imageUrls** — All listing images (full size)
- **category** — Listing category (PC, Auto, Mobil, etc.)
- **listingId** — Unique Bazos listing ID
- **views** — Number of views on the listing
- **url** — Full listing URL
- **country** — CZ or SK
- **scrapedAt** — ISO timestamp of extraction

**Basic mode** (with `scrapeDetails` off) returns listing-page data only: title, price, description snippet, location, date, and thumbnail image. Much faster for bulk monitoring.

### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | String | `"notebook"` | Keyword search in Czech or Slovak |
| `country` | Enum | `CZ` | `CZ` (bazos.cz, CZK) or `SK` (bazos.sk, EUR) |
| `categoryUrls` | Array | — | Direct category or listing URLs to scrape |
| `maxResults` | Integer | `100` | Maximum listings to return (up to 10,000) |
| `maxPages` | Integer | `5` | Max pagination pages to scrape (20 listings/page) |
| `scrapeDetails` | Boolean | `true` | Visit detail pages for full data (slower but richer) |
| `proxyConfiguration` | Object | — | Proxy settings for reliability |

#### Tips

- Bazos has minimal anti-bot protection, but proxies help for large runs (1,000+ listings).
- Each page has 20 listings. With `maxPages: 5`, you get up to 100 listings per search.
- Use native-language search terms for best results: "telefon" (phone), "auto" (car), "kolo" (bicycle), "byt" (apartment).
- Category URLs use subdomains: `https://pc.bazos.cz/`, `https://auto.bazos.sk/`, `https://mobil.bazos.cz/`.
- The `scrapeDetails` toggle is your speed/depth tradeoff. Off = 5-10x faster but no seller info or full descriptions.

### Output

Here is realistic example output from Bazos.cz:

```json
[
  {
    "listingTitle": "Prodej notebook Lenovo ThinkPad T14 Gen 3",
    "price": 15000,
    "currency": "CZK",
    "listingDescription": "Prodavam notebook Lenovo ThinkPad T14 Gen 3, AMD Ryzen 5 PRO 6650U, 16GB RAM, 512GB SSD, 14\" FHD IPS, podsvicena klavesnice, ctecka otisku prstu. Baterie drzi 6-7 hodin. Stav velmi dobry, minimalni pouziti. Puvodni krabice a nabijecka.",
    "sellerName": "Martin Novak",
    "location": "Praha",
    "postalCode": "110 00",
    "datePosted": "2026-06-05",
    "imageUrl": "https://www.bazos.cz/img/1/123/219123456.jpg",
    "imageUrls": [
      "https://www.bazos.cz/img/1/123/219123456.jpg",
      "https://www.bazos.cz/img/1/123/219123456b.jpg",
      "https://www.bazos.cz/img/1/123/219123456c.jpg"
    ],
    "category": "Pc",
    "listingId": "219123456",
    "views": 342,
    "url": "https://pc.bazos.cz/inzerat/219123456/prodej-notebook-lenovo-thinkpad-t14-gen-3.php",
    "country": "CZ",
    "scrapedAt": "2026-06-07T10:30:15.000Z"
  },
  {
    "listingTitle": "iPhone 15 Pro 256GB - zaruka",
    "price": 22500,
    "currency": "CZK",
    "listingDescription": "Prodavam iPhone 15 Pro 256GB v cernem provedeni. Telefon je v perfektnim stavu, vzdy pouzivan s obalem a ochrannym sklem. Zaruka do 03/2027. Kompletni baleni vcetne nabijecky a kabelu.",
    "sellerName": "Jana Svobodova",
    "location": "Brno",
    "postalCode": "602 00",
    "datePosted": "2026-06-06",
    "imageUrl": "https://www.bazos.cz/img/1/789/219789012.jpg",
    "imageUrls": [
      "https://www.bazos.cz/img/1/789/219789012.jpg",
      "https://www.bazos.cz/img/1/789/219789012b.jpg"
    ],
    "category": "Mobil",
    "listingId": "219789012",
    "views": 891,
    "url": "https://mobil.bazos.cz/inzerat/219789012/iphone-15-pro-256gb-zaruka.php",
    "country": "CZ",
    "scrapedAt": "2026-06-07T10:30:18.000Z"
  },
  {
    "listingTitle": "Predaj Skoda Octavia Combi 2.0 TDI",
    "price": 12900,
    "currency": "EUR",
    "listingDescription": "Predavam Skoda Octavia Combi 2.0 TDI, rok 2019, 150 000 km, automat DSG, full vybava. Pravidelny servis u autorizovaneho dealera. STK do 2027. Moznost vymeny za SUV.",
    "sellerName": "Peter Horvath",
    "location": "Bratislava",
    "postalCode": "811 01",
    "datePosted": "2026-06-04",
    "imageUrl": "https://www.bazos.sk/img/1/456/192456789.jpg",
    "imageUrls": [
      "https://www.bazos.sk/img/1/456/192456789.jpg",
      "https://www.bazos.sk/img/1/456/192456789b.jpg",
      "https://www.bazos.sk/img/1/456/192456789c.jpg",
      "https://www.bazos.sk/img/1/456/192456789d.jpg"
    ],
    "category": "Auto",
    "listingId": "192456789",
    "views": 1547,
    "url": "https://auto.bazos.sk/inzerat/192456789/predaj-skoda-octavia-combi-20-tdi.php",
    "country": "SK",
    "scrapedAt": "2026-06-07T10:30:21.000Z"
  }
]
````

### How much does it cost?

Bazos Scraper uses CheerioCrawler (HTTP-only, no browser) which keeps costs very low. Bazos's minimal HTML means fast parsing and tiny response sizes.

| Scenario | Listings | Detail pages | Estimated cost | Time |
|----------|----------|-------------|---------------|------|
| Quick search | 20 | On | ~$0.005 | ~5 sec |
| Category sweep | 100 | On | ~$0.02 | ~30 sec |
| Large search | 500 | On | ~$0.08 | ~3 min |
| Bulk listing mode | 1,000 | Off | ~$0.02 | ~1 min |
| Full category dump | 2,000 | On | ~$0.30 | ~10 min |

The `scrapeDetails: false` mode is dramatically cheaper because it skips individual listing pages. Use it for price-only monitoring or bulk market scans.

### Can I integrate?

Bazos Scraper connects to the full Apify integration ecosystem:

- **Apify API** — Trigger runs programmatically, stream results in real-time
- **Webhooks** — Notify your systems when scraping completes
- **Google Sheets** — Auto-export Bazos listings for team review
- **Zapier / Make** — Build no-code automations triggered by new listings
- **Slack alerts** — Get notified when specific items appear at target prices
- **Scheduled runs** — Set up daily monitoring with Apify Schedules
- **Direct download** — CSV, JSON, XML, or Excel export from the Apify Console

### Can I use it as an API?

Use Bazos Scraper as a Czech/Slovak classifieds API. Start runs, poll for results, and process data in your application.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/bazos-scraper").call(run_input={
    "searchQuery": "iPhone",
    "country": "CZ",
    "maxResults": 50,
    "scrapeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    price = item.get("price", "N/A")
    currency = item.get("currency", "CZK")
    print(f"{item['listingTitle']} - {price} {currency} ({item['location']})")
```

#### JavaScript

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/bazos-scraper").call({
  searchQuery: "auto",
  country: "SK",
  maxResults: 200,
  maxPages: 10,
  scrapeDetails: true,
});

const { items } = await client
  .dataset(run.defaultDatasetId)
  .listItems();

items.forEach((item) => {
  console.log(`${item.listingTitle} - ${item.price} ${item.currency} (${item.location})`);
});
```

### FAQ

#### What is the difference between bazos.cz and bazos.sk?

Bazos.cz serves the Czech Republic with prices in CZK (Czech koruna). Bazos.sk serves Slovakia with prices in EUR (euro). Both sites have identical structure and the same categories. Use the `country` input parameter to choose which site to scrape.

#### What categories are available?

Both sites have 20+ categories including: Auto (cars), Motorky (motorcycles), PC (computers), Mobil (phones), Elektro (electronics), Reality (real estate), Prace/Praca (jobs), Nabytek (furniture), Obleceni (clothing), Sport, Knihy (books), Foto (photography), Hudba (music), and more. Each category uses its own subdomain (e.g., `pc.bazos.cz`, `auto.bazos.sk`).

#### What does "Dohodou" mean for price?

"Dohodou" means "negotiable" or "by agreement" — the seller hasn't listed a fixed price. These listings return `null` for the price field. "V textu" means the price is mentioned somewhere in the description text. "Zdarma" means free (price = 0).

#### Does this scraper handle anti-bot protection?

Bazos is famously simple with minimal anti-bot measures. The scraper uses browser-like headers for reliability, but Bazos generally does not block automated requests. Proxies are recommended for high-volume runs (1,000+ listings) to avoid rate limiting.

#### Can I scrape bazos.pl (Poland) or bazos.at (Austria)?

This actor currently supports bazos.cz and bazos.sk. The Polish and Austrian versions have similar structure. Contact us if you need these added.

### Limitations

- **Phone numbers** — Bazos partially hides phone numbers behind a "zobraz cislo" (show number) click that requires JavaScript. The scraper captures the visible part but not the full number.
- **Expired listings** — Bazos removes expired listings. The scraper only finds currently active listings.
- **Image count** — Some listings have many images (10+). The scraper captures all available images from the detail page.
- **Price format** — Negotiable prices ("Dohodou") return null. Prices in text ("V textu") also return null — check the description field.
- **Rate limiting** — Very aggressive scraping (10,000+ listings without proxies) may trigger temporary IP blocks. Use proxies and moderate concurrency.

### Other Central European classifieds scrapers

Build a complete view of Central European secondhand markets:

- **[Bazos Scraper](https://apify.com/studio-amba/bazos-scraper)** — Czech Republic and Slovakia (this actor)
- Check the [Apify Store](https://apify.com/store) for more European classifieds scrapers from Studio AMBA.

### Your feedback

If you notice any data quality issues, missing fields, or broken runs, let us know through the Apify Console. Bazos rarely changes its structure (it's been nearly identical since 2004), but we monitor and update this scraper to ensure reliable operation.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for listings by keyword. Uses native-language search (Czech for .cz, Slovak for .sk). Examples: "notebook", "iPhone", "kolo" (bicycle), "auto".

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

Which Bazos site to scrape. CZ = bazos.cz (Czech Republic, prices in CZK), SK = bazos.sk (Slovakia, prices in EUR).

## `categoryUrls` (type: `array`):

Direct category or listing URLs from bazos.cz or bazos.sk. Examples: "https://pc.bazos.cz/" (all PC listings), "https://auto.bazos.sk/" (all cars in Slovakia). Overrides searchQuery when provided.

## `maxResults` (type: `integer`):

Maximum number of listings to return.

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

Maximum number of pagination pages to scrape. Each page has 20 listings.

## `scrapeDetails` (type: `boolean`):

Visit each listing's detail page to get full description, seller name, phone number, and all images. Slower but gives much richer data.

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

Proxy settings. Bazos is a simple HTML site with minimal anti-bot protection, but proxies help for large runs.

## Actor input object example

```json
{
  "searchQuery": "notebook",
  "country": "CZ",
  "maxResults": 20,
  "maxPages": 5,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CZ"
  }
}
```

# 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 = {
    "searchQuery": "notebook",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CZ"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/bazos-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 = {
    "searchQuery": "notebook",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CZ",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/bazos-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 '{
  "searchQuery": "notebook",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CZ"
  }
}' |
apify call studio-amba/bazos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bazos Scraper - Czech & Slovak Classifieds Marketplace",
        "description": "Scrape classifieds listings from Bazos.cz and Bazos.sk. Extract prices, descriptions, seller info, images, and location data. No login required.",
        "version": "0.1",
        "x-build-id": "JNlbd3iPQ3Zy2szMe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~bazos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-bazos-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/studio-amba~bazos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-bazos-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/studio-amba~bazos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-bazos-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for listings by keyword. Uses native-language search (Czech for .cz, Slovak for .sk). Examples: \"notebook\", \"iPhone\", \"kolo\" (bicycle), \"auto\"."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "CZ",
                            "SK"
                        ],
                        "type": "string",
                        "description": "Which Bazos site to scrape. CZ = bazos.cz (Czech Republic, prices in CZK), SK = bazos.sk (Slovakia, prices in EUR).",
                        "default": "CZ"
                    },
                    "categoryUrls": {
                        "title": "Category or Listing URLs",
                        "type": "array",
                        "description": "Direct category or listing URLs from bazos.cz or bazos.sk. Examples: \"https://pc.bazos.cz/\" (all PC listings), \"https://auto.bazos.sk/\" (all cars in Slovakia). Overrides searchQuery when provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of pagination pages to scrape. Each page has 20 listings.",
                        "default": 5
                    },
                    "scrapeDetails": {
                        "title": "Scrape Listing Details",
                        "type": "boolean",
                        "description": "Visit each listing's detail page to get full description, seller name, phone number, and all images. Slower but gives much richer data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Bazos is a simple HTML site with minimal anti-bot protection, but proxies help for large runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
