# Bazos.sk Scraper (`solidcode/bazos-scraper`) Actor

\[💰 $1.7 / 1K] Extract classified ads from Bazos.sk, Slovakia's biggest free marketplace. Search cars, real estate, electronics, jobs and 20+ categories by keyword, postal code, radius and price. Returns title, price, location, seller, photos, description, views and ad URL.

- **URL**: https://apify.com/solidcode/bazos-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Bazos.sk Scraper

Pull classified ads from Bazos.sk — Slovakia's biggest free marketplace — with title, price, location, seller name, posted date, every photo URL, full description, and the ad's own view count, one clean row per listing. Search by keyword, narrow to any of 20 categories, and filter by postal code, radius, and price range. Built for resellers, price researchers, and lead-generation teams who need structured Slovak marketplace data without copy-pasting ads one page at a time.

### Why This Scraper?

- **20 named categories** — Cars, Motorcycles, Real Estate, Jobs, Animals, Kids, Machinery, House & Garden, Computers, Mobile Phones, Photo, Electronics, Sport, Music, Tickets, Books, Furniture, Clothing, Services, and Other, or search across all of them at once.
- **Postal-code + radius targeting in kilometres** — centre a search on any Slovak PSČ (e.g. 81101 Bratislava, 04001 Košice) and pull only ads within the distance you set.
- **Newest, cheapest, or most-expensive sorting** — collect the freshest listings first for monitoring, or the lowest-priced first for arbitrage hunting.
- **Every photo URL per ad** — the full image carousel for each listing, plus a dedicated main-photo field, filtered to that exact ad so you never pull a neighbouring listing's pictures.
- **Honest price handling** — numeric price in euros where available, plus the raw price text so you keep "Zadarmo" (free), "Dohodou" (negotiable), and "V texte" listings instead of dropping them.
- **The Bazos-specific view count** — the number of times each ad has been seen, a demand signal most marketplace scrapers ignore.
- **Multi-keyword runs, deduplicated by ad ID** — queue several search terms in one run and get a single clean list with no repeated ads, even across overlapping searches.
- **Paste-a-URL power mode** — drop any Bazos.sk search, category, or individual ad page in and the scraper collects it as-is, filters and all.

### Use Cases

**Reselling & Arbitrage**
- Spot underpriced phones, electronics, and cars before they sell
- Sort cheapest-first to surface flip candidates fast
- Track "Zadarmo" (free) and "Dohodou" (negotiable) listings most tools discard
- Compare asking prices for the same model across categories

**Market & Price Research**
- Benchmark second-hand prices by category and region
- Measure listing volume and demand using each ad's view count
- Track how prices shift over time for a given keyword
- Compare Bratislava, Košice, and rural-region pricing by postal code

**Lead Generation**
- Build outreach lists of sellers with name, location, and ad URL
- Target a single category and price band for qualified prospects
- Identify high-activity sellers by view count and posting frequency
- Focus on a specific region with postal-code + radius filtering

**Inventory & Competitor Monitoring**
- Watch newest-first to catch fresh listings the moment they post
- Monitor a competitor's category for new stock and price moves
- Track real-estate or vehicle inventory in a target town
- Re-run a saved keyword to keep a daily snapshot of a niche

### Getting Started

#### Search by Keyword

The simplest run — one Slovak keyword across the whole site:

```json
{
    "searchQueries": ["iphone"],
    "maxResults": 100
}
````

#### Keyword + Category + Price

Narrow to a category and a price band:

```json
{
    "searchQueries": ["octavia"],
    "category": "auto",
    "priceMin": 2000,
    "priceMax": 8000,
    "maxResults": 200
}
```

#### Local Search with Radius and Sorting

Find the cheapest matching ads near a postal code:

```json
{
    "searchQueries": ["pohovka"],
    "category": "nabytok",
    "postalCode": "81101",
    "radiusKm": 25,
    "sortBy": "price-asc",
    "maxResults": 100
}
```

#### Paste Bazos.sk URLs (Power User)

Already have a filtered search or a specific ad open in your browser? Paste the URLs directly — they override the guided fields:

```json
{
    "startUrls": [
        "https://www.bazos.sk/search.php?hledat=macbook&rubriky=pc",
        "https://mobil.bazos.sk/inzerat/12345678/iphone-15-pro.php"
    ],
    "maxResults": 100
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["iphone"]` | Keywords to search for (Slovak terms usually match best — e.g. "iphone", "octavia", "pohovka"). Each keyword runs as its own search and results are deduplicated by ad ID. Leave empty to collect the unfiltered listing for the chosen category. |
| `category` | select | `All categories` | Limit results to a single Bazos.sk category. Choose from Cars, Motorcycles, Real Estate, Jobs, Animals, Kids, Machinery, House & Garden, Computers, Mobile Phones, Photo, Electronics, Sport, Music, Tickets, Books, Furniture, Clothing, Services, Other — or keep All categories. |

#### Location & Price

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `postalCode` | string | `""` | Slovak postal code to centre the search on — e.g. "81101" for Bratislava or "04001" for Košice. Leave empty to search all of Slovakia. |
| `radiusKm` | integer | `null` | Only include ads within this many kilometres of the postal code. Ignored when no postal code is set. |
| `priceMin` | integer | `null` | Only include ads at or above this price, in euros (€). |
| `priceMax` | integer | `null` | Only include ads at or below this price, in euros (€). |
| `sortBy` | select | `Newest first` | Order in which to collect ads: Newest first, Cheapest first, or Most expensive first. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[]` | Paste Bazos.sk URLs directly — search-result pages, category pages (e.g. https://auto.bazos.sk/), or individual ad pages. When provided, these override the keyword, category, location, and price fields above. |
| `maxResults` | integer | `100` | Maximum number of ads to collect across all searches and URLs. Set to 0 for no cap. Ads are collected in full pages, so the final page may overshoot this number by a few rows. |

### Output

Each ad becomes one flat row. Here's a representative result:

```json
{
    "id": "171234567",
    "url": "https://mobil.bazos.sk/inzerat/171234567/iphone-15-pro-256gb.php",
    "title": "iPhone 15 Pro 256GB",
    "description": "Predám iPhone 15 Pro 256GB v záruke, kompletné balenie, bez škrabancov. Osobný odber Bratislava alebo zaslanie poštou.",
    "price": 850,
    "currency": "EUR",
    "priceText": "850 €",
    "category": "mobil",
    "location": "Bratislava",
    "postalCode": "81101",
    "sellerName": "Martin",
    "sellerPhone": "094...",
    "views": 312,
    "imageUrl": "https://www.bazos.sk/img/1/171/171234567.jpg",
    "imageUrls": [
        "https://www.bazos.sk/img/1/171/171234567.jpg",
        "https://www.bazos.sk/img/2/171/171234567.jpg"
    ],
    "publishedAt": "2026-05-30",
    "searchQuery": "iphone",
    "sourceListUrl": "https://www.bazos.sk/search.php?hledat=iphone&rubriky=mobil",
    "scrapedAt": "2026-06-02T14:30:00+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Bazos.sk ad identifier |
| `url` | string | Direct link to the ad |
| `title` | string | Ad headline |
| `description` | string | Full ad body text |
| `category` | string | Bazos.sk category slug (e.g. "auto", "reality", "mobil") |
| `publishedAt` | string | Date the ad was posted (YYYY-MM-DD) |
| `views` | number | Number of times the ad has been viewed |

#### Price

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Numeric price in euros; empty when the ad has no fixed price |
| `currency` | string | Always "EUR" |
| `priceText` | string | Raw price label as shown on the ad — a euro amount, "Zadarmo" (free), "Dohodou" (negotiable), or "V texte" |

#### Location & Seller

| Field | Type | Description |
|-------|------|-------------|
| `location` | string | City or municipality the ad is listed in |
| `postalCode` | string | Slovak postal code (PSČ) of the ad |
| `sellerName` | string | Seller's display name |
| `sellerPhone` | string | Seller's masked phone prefix as shown on the ad (e.g. "094...") — the full number is not published by Bazos.sk |

#### Media & Provenance

| Field | Type | Description |
|-------|------|-------------|
| `imageUrl` | string | Main photo URL |
| `imageUrls` | array | All photo URLs for the ad |
| `searchQuery` | string | The keyword that produced this row (empty for pasted URLs) |
| `sourceListUrl` | string | The search or category URL the ad came from |
| `scrapedAt` | string | ISO timestamp of when the row was collected |

### Tips for Best Results

- **Use Slovak keywords** — Bazos.sk is a Slovak marketplace, so native terms ("pohovka" for sofa, "byt" for flat, "auto" for car) return far more matches than English ones.
- **Start with 50–100 results** to confirm your keyword and filters are right, then raise `maxResults` once the output looks good.
- **Pin an exact search with `startUrls`** — open Bazos.sk in your browser, apply every filter you want, then paste that URL in. It captures filters the guided fields don't, and overrides them entirely.
- **Widen the radius for rural areas** — small towns have fewer ads, so a 50–100 km radius around a regional postal code returns far more than a tight 10 km.
- **Queue several keywords in one run** — list every term you care about in `searchQueries`; results are deduplicated by ad ID, so overlapping searches never produce repeat rows.
- **`sellerPhone` is a masked prefix only** — Bazos.sk publishes just the first few digits (e.g. "094..."); treat it as a partial signal, not a dialable number.
- **Set `maxResults` to 0 for a full sweep** of a narrow keyword or category when you want everything available rather than a fixed cap.

### Pricing

**From $1.70 per 1,000 results** — undercutting the going rate for Bazos.sk data while returning a far richer 19-field row. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.20 | $0.19 | $0.18 | $0.17 |
| 1,000 | $2.00 | $1.90 | $1.80 | $1.70 |
| 10,000 | $20.00 | $19.00 | $18.00 | $17.00 |
| 100,000 | $200.00 | $190.00 | $180.00 | $170.00 |

A "result" is any ad row in the output dataset. Bronze, Silver, and Gold are Apify's loyalty tiers — subscribers pay progressively less.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, price analysis, and lead generation using publicly available classified ads. Users are responsible for complying with applicable laws and Bazos.sk's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as seller names) in line with applicable privacy regulations.

# Actor input Schema

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

Keywords to search for on Bazos.sk (Slovak terms usually match best — e.g. 'iphone', 'octavia', 'pohovka'). Each keyword runs as its own search and results are deduplicated by ad ID. Leave empty to collect the unfiltered listing for the chosen category.

## `category` (type: `string`):

Limit results to a single Bazos.sk category. Leave on 'All categories' to search across the whole site.

## `postalCode` (type: `string`):

Slovak postal code to centre the search on — e.g. '81101' for Bratislava or '04001' for Košice. Combine with 'Search Radius' to find ads near a location. Leave empty to search all of Slovakia.

## `radiusKm` (type: `integer`):

Only include ads within this many kilometres of the postal code above. Ignored when no postal code is set. Leave empty for no distance limit.

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

Only include ads at or above this price, in euros (€). Leave empty for no minimum.

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

Only include ads at or below this price, in euros (€). Leave empty for no maximum.

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

Order in which to collect ads from Bazos.sk. Newest first gives the most recent ads first.

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

Power-user input. Paste Bazos.sk URLs directly — search-result pages, category pages (e.g. https://auto.bazos.sk/), or individual ad pages. When provided, these override the Search Keywords / Category / Location / Price fields above.

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

Maximum number of ads to collect across all searches and URLs. Set to 0 for no cap (an internal safety limit of 100,000 still applies). Ads are collected in full pages, so the final page may overshoot this number by a few rows.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone"
  ],
  "category": "all",
  "sortBy": "newest",
  "startUrls": [],
  "maxResults": 100
}
```

# Actor output Schema

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

Table of ads with the key fields at a glance — title, price, category, location, postal code, posted date and ad URL.

## `details` (type: `string`):

Full per-ad fields including description, all photo URLs, postal code, seller name and masked phone prefix, view count and timestamps.

# 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 = {
    "searchQueries": [
        "iphone"
    ],
    "category": "all",
    "postalCode": "",
    "sortBy": "newest",
    "startUrls": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["iphone"],
    "category": "all",
    "postalCode": "",
    "sortBy": "newest",
    "startUrls": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchQueries": [
    "iphone"
  ],
  "category": "all",
  "postalCode": "",
  "sortBy": "newest",
  "startUrls": [],
  "maxResults": 100
}' |
apify call solidcode/bazos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bazos.sk Scraper",
        "description": "[💰 $1.7 / 1K] Extract classified ads from Bazos.sk, Slovakia's biggest free marketplace. Search cars, real estate, electronics, jobs and 20+ categories by keyword, postal code, radius and price. Returns title, price, location, seller, photos, description, views and ad URL.",
        "version": "1.0",
        "x-build-id": "N69I3HrLov0Mmn5jF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~bazos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~bazos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~bazos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for on Bazos.sk (Slovak terms usually match best — e.g. 'iphone', 'octavia', 'pohovka'). Each keyword runs as its own search and results are deduplicated by ad ID. Leave empty to collect the unfiltered listing for the chosen category.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "auto",
                            "motocykle",
                            "reality",
                            "praca",
                            "zvierata",
                            "deti",
                            "stroje",
                            "dom",
                            "pc",
                            "mobil",
                            "foto",
                            "elektro",
                            "sport",
                            "hudba",
                            "vstupenky",
                            "knihy",
                            "nabytok",
                            "oblecenie",
                            "sluzby",
                            "ostatne"
                        ],
                        "type": "string",
                        "description": "Limit results to a single Bazos.sk category. Leave on 'All categories' to search across the whole site.",
                        "default": "all"
                    },
                    "postalCode": {
                        "title": "Postal Code (PSČ)",
                        "type": "string",
                        "description": "Slovak postal code to centre the search on — e.g. '81101' for Bratislava or '04001' for Košice. Combine with 'Search Radius' to find ads near a location. Leave empty to search all of Slovakia."
                    },
                    "radiusKm": {
                        "title": "Search Radius (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include ads within this many kilometres of the postal code above. Ignored when no postal code is set. Leave empty for no distance limit."
                    },
                    "priceMin": {
                        "title": "Minimum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include ads at or above this price, in euros (€). Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include ads at or below this price, in euros (€). Leave empty for no maximum."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "newest",
                            "price-asc",
                            "price-desc"
                        ],
                        "type": "string",
                        "description": "Order in which to collect ads from Bazos.sk. Newest first gives the most recent ads first.",
                        "default": "newest"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste Bazos.sk URLs directly — search-result pages, category pages (e.g. https://auto.bazos.sk/), or individual ad pages. When provided, these override the Search Keywords / Category / Location / Price fields above.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of ads to collect across all searches and URLs. Set to 0 for no cap (an internal safety limit of 100,000 still applies). Ads are collected in full pages, so the final page may overshoot this number by a few rows.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
