# OLX Poland Classifieds Scraper – olx.pl Ads, Prices & Sellers (`haketa/olx-poland-classifieds-scraper`) Actor

Scrape classified ads from OLX Poland (olx.pl): title, price, price drops, condition, all item attributes, seller, location and photos. Search by keyword with filters for price, region, condition and sort — or scrape specific listing URLs.

- **URL**: https://apify.com/haketa/olx-poland-classifieds-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<h1 align="center">OLX Poland Classifieds Scraper 🇵🇱</h1>

<p align="center">
  <img alt="Platform" src="https://img.shields.io/badge/Made%20for-Apify-97D700?style=for-the-badge">
  <img alt="Site" src="https://img.shields.io/badge/olx.pl-Poland-002F5F?style=for-the-badge">
  <img alt="No code" src="https://img.shields.io/badge/No%20code-required-4C8BF5?style=for-the-badge">
  <img alt="Speed" src="https://img.shields.io/badge/Fast-API%20based-8A2BE2?style=for-the-badge">
  <img alt="Export" src="https://img.shields.io/badge/Export-Excel%20%7C%20CSV%20%7C%20JSON%20%7C%20API-FF7A00?style=for-the-badge">
</p>

<p align="center"><b>Turn Poland's biggest classifieds site into clean, structured, export-ready data.</b></p>

Scrape ads from **OLX Poland (olx.pl)** — the country's #1 marketplace for electronics, cars, real estate, furniture, fashion and everything else. Search by keyword with filters for **price, region, condition and sort order**, and get back the **price (and price drops), every item attribute, the seller, exact location and photos** for each ad.

Fast, reliable and **no code required** — export to **JSON, CSV or Excel** in minutes.

---

### ⚡ At a glance

| | |
|---|---|
| 🔎 **Search** | Any keyword, with price / region / condition / sort filters |
| 💰 **Prices & drops** | Current price, previous price and a **price-dropped** flag |
| 🧩 **Every attribute** | Category-aware item parameters (car mileage, phone memory, m²…) |
| 👤 **Seller data** | Name, business-vs-private, member-since, phone availability |
| 📍 **Location** | City, district and voivodeship |
| 🖼️ **Photos** | Full-resolution image URLs |
| ⚡ **Fast & reliable** | Direct data source — quick, stable and cheap |
| 💾 **Export** | Excel, CSV, JSON, HTML, RSS or API |

---

### 📌 Why this Actor?

Most OLX scrapers give you a title and a price. This one returns the **complete ad**:

- 💰 **Price intelligence** — current price, the **previous price** when a seller lowered it, a `priceDropped` flag, currency and whether it's negotiable.
- 🧩 **Category-aware attributes** — the full parameter set for each ad: for cars, mileage, year, fuel, gearbox and power; for phones, model and storage; for property, area and rooms — automatically.
- 👤 **Seller insight** — name, **business vs. private**, when they joined OLX, last-seen time and whether a phone number is available — great for lead generation and reseller research.
- 📍 **Precise location** — city, district and region (voivodeship).
- 🖼️ **All photos** at the resolution you choose.

Because it reads a **structured data source directly**, it's fast, stable and inexpensive — no fragile page rendering.

---

### ✨ What you get (data fields)

> **Coverage key:**  🟢 almost every ad · 🟡 when present · ⚪ situational (e.g. only on price drops)

#### 💰 Price &amp; condition

| Field | Description | Coverage |
|-------|-------------|:--------:|
| `price` / `priceLabel` | Numeric price and formatted label (e.g. `1 850 zł`) | 🟢 |
| `currency` | Currency (usually PLN) | 🟢 |
| `negotiable` | Whether the price is negotiable | 🟢 |
| `previousPrice` | Earlier price, when the seller lowered it | ⚪ |
| `priceDropped` | `true` when the current price is below the previous | ⚪ |
| `condition` | New / Used / Refurbished / Damaged | 🟡 |

#### 📦 Item

| Field | Description | Coverage |
|-------|-------------|:--------:|
| `title` | Ad title | 🟢 |
| `description` | Full description (plain text) | 🟢 |
| `categoryType` | Category (electronics, automotive, real estate…) | 🟢 |
| `parameters` | Category-specific attributes (name → value) | 🟢 |

#### 👤 Seller (lead data)

| Field | Description | Coverage |
|-------|-------------|:--------:|
| `sellerName` | Seller display name | 🟢 |
| `isBusinessSeller` | `true` = business · `false` = private | 🟢 |
| `sellerRegisteredAt` | When the seller joined OLX | 🟢 |
| `sellerLastSeen` | Seller's last activity | 🟡 |
| `hasPhone` | Whether a phone number is published | 🟢 |

#### 📍 Location, media &amp; meta

| Field | Description | Coverage |
|-------|-------------|:--------:|
| `city` / `district` / `region` | Location | 🟢 |
| `latitude` / `longitude` | GPS coordinates | 🟡 |
| `photos` / `photosCount` | Image URLs | 🟢 |
| `url` / `id` | Ad link and OLX offer ID | 🟢 |
| `createdTime` / `lastRefreshTime` | Posting & refresh time | 🟢 |
| `scrapedAt` | Collection timestamp | 🟢 |

---

### 🚀 Quick start

1. Click **Try for free / Start**.
2. Add your **Search keywords** (one per line, Polish works best):
````

iphone
rower górski
opel astra

````
3. *(Optional)* Set **Region**, **Min/Max price**, **Condition** and **Sort by**.
4. Click **Save &amp; Start**, then export from the **Dataset** tab.

> 💡 **Tip:** Leave everything blank and hit Start to get an instant **sample of ads** so you can see the output format first.

---

### 🎯 Use cases

| Use case | What it delivers |
|----------|------------------|
| 🛒 **Deal hunting &amp; price comparison** | Pull every ad for a product, sort by price, and spot the best offers instantly. |
| 🔁 **Reselling &amp; arbitrage** | Track **price drops** and filter by condition to find items to flip. |
| 📊 **Market &amp; price research** | Analyse prices, conditions and volumes across a category or region. |
| 🧲 **Lead generation** | Filter `isBusinessSeller` to build lists of business sellers in a niche. |
| 🚗 **Car &amp; property data** | Get structured car specs (mileage, year, fuel…) or property attributes (area, rooms). |
| 🔔 **Price monitoring** | Re-run on a schedule to track new ads and price changes over time. |

---

### ⚙️ Input reference

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| **Search keywords** | list | *sample* | One keyword per line. Each is searched and merged. |
| **Region (voivodeship)** | select | All Poland | Limit to one of Poland's 16 regions. |
| **Min / Max price (PLN)** | number | — | Price range filter. |
| **Condition** | select | All | All / New / Used. |
| **Sort by** | select | Relevance | Relevance, Newest, Price ↑, Price ↓. |
| **Category ID** | number | — | Advanced: restrict to a numeric OLX category. |
| **Start URLs** | list | — | Paste offer pages or search/category URLs. |
| **Max results** | number | `0` | Cap the run. `0` = no limit (OLX returns up to 1,000 per search). |
| **Photo size** | select | 1000×1000 | Resolution for image URLs. |
| **Proxy configuration** | object | Datacenter | Default is more than enough. |

#### 📥 Example input

```json
{
"searchQueries": ["opel astra", "vw golf"],
"regionId": "4",
"priceMin": 5000,
"priceMax": 25000,
"condition": "used",
"sortBy": "price-asc",
"maxItems": 500
}
````

<details>
<summary><b>🔗 Scrape a specific offer or a search you built on OLX</b></summary>

```json
{
  "startUrls": [
    "https://www.olx.pl/d/oferta/iphone-16e-256gb-CID99-ID1bsCrL.html",
    "https://www.olx.pl/oferty/q-macbook-air/"
  ]
}
```

</details>

***

### 📤 Example output

```json
{
  "id": 1044622058,
  "url": "https://www.olx.pl/d/oferta/iphone-7-128gb-black-...-ID18H7US.html",
  "title": "iPhone 7 128gb Black Bateria 100% iOS 15",
  "price": 450,
  "priceLabel": "450 zł",
  "currency": "PLN",
  "negotiable": false,
  "previousPrice": 520,
  "priceDropped": true,
  "condition": "Used",
  "categoryType": "electronics",
  "parameters": {
    "Model telefonu": "iPhone 7",
    "Wbudowana pamięć": "128GB",
    "Kolor": "Czarny"
  },
  "description": "iPhone 7 128gb, kolor czarny, bateria 100% …",
  "city": "Warszawa",
  "district": "Praga-Południe",
  "region": "Mazowieckie",
  "sellerName": "SuperMen S",
  "isBusinessSeller": false,
  "sellerRegisteredAt": "2018-12-20T18:51:40+01:00",
  "hasPhone": true,
  "photos": ["https://ireland.apollo.olxcdn.com/v1/files/...-PL/image;s=1000x1000"],
  "photosCount": 6,
  "createdTime": "2026-07-15T11:53:08+02:00",
  "scrapedAt": "2026-07-24T13:10:00.000Z"
}
```

***

### 💡 Tips & best practices

- ✅ **Search in Polish** for the most results (e.g. `rower` not `bike`, `mieszkanie` not `apartment`).
- ✅ **Stack filters** — combine keyword + region + price + condition for a precise dataset.
- ✅ **Find deals** — sort by *Price: low to high*, or filter `priceDropped = true` for reduced items.
- ✅ **Separate businesses from private sellers** with `isBusinessSeller`.
- ✅ **One search returns up to 1,000 ads** — split broad searches by region or price band to go deeper.
- ✅ **Schedule it** to monitor new ads and price changes.

***

### ❓ FAQ

**What can I scrape?**
Any public ad on OLX Poland — electronics, cars, real estate, furniture, fashion, services and more.

**Do I need to code?**
No. Enter keywords and filters, click Start, and export.

**Can I get the seller's phone number?**
OLX only reveals phone numbers to logged-in users, so the actual number isn't included. The `hasPhone` field tells you whether one is available.

**How many ads can I get?**
OLX returns up to 1,000 results per individual search. Use region or price filters to split large categories and collect more.

**Can I scrape a specific ad or a search I built on OLX?**
Yes — paste the URL(s) into **Start URLs**.

**In what format is the data?**
Structured JSON by default, exportable to CSV, Excel, HTML, RSS or via API.

**How fresh is the data?**
Every run fetches live data, so results reflect what's on OLX at run time.

***

### 📊 Output & integrations

Results are stored in a standard Apify dataset. You can:

- 👀 Preview them in a clean **table view** in the Console.
- 💾 Export to **JSON, CSV, Excel, HTML, or RSS**.
- 🔌 Pull them via the **Apify API**.
- 🔗 Push them to **Google Sheets, Make, Zapier, Airbyte** and more.

***

### ⚖️ Legal & responsible use

This Actor collects **publicly available classified-ad information** for legitimate purposes such as price research, deal finding and market analysis.

- Use the data in compliance with **GDPR** and any other applicable laws, including rules on **marketing and electronic communications**.
- Personal data still requires a lawful basis for processing — ensure you have one and honour opt-out requests.
- Respect the source website's terms of service and use the data responsibly.
- You are responsible for how you use the collected data.

If you are unsure about a specific use case, consult your legal counsel before large-scale collection.

***

### 🛟 Support

Found a bug, need an extra field, or want a tweak? **Open an issue** on the Actor's Issues tab — feedback is welcome and helps improve the Actor.

<p align="center"><b>Happy bargain hunting! 🇵🇱</b></p>

# Actor input Schema

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

One keyword or phrase per line (in Polish for best results) — for example 'iphone', 'rower górski', 'sofa narożna'. Each keyword is searched and the results are merged. Leave blank to get an automatic sample.

## `regionId` (type: `string`):

Limit results to one Polish region. Leave as 'All Poland' to search the whole country.

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

Only return ads at or above this price, in Polish złoty. Leave blank for no minimum.

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

Only return ads at or below this price, in Polish złoty. Leave blank for no maximum.

## `condition` (type: `string`):

Filter by item condition.

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

Order of the results.

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

Optional. Restrict to a specific OLX category by numeric ID (you can read it from a category URL). Leave blank to search all categories.

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

Optional. Paste OLX Poland URLs directly — either individual offer pages (…/d/oferta/…-IDxxxx.html) or search/category result pages.

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

Maximum number of ads to collect in this run. Set to 0 for no limit. Note: OLX returns up to 1,000 results per individual search.

## `photoSize` (type: `string`):

Resolution used when building image URLs (width x height).

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

Proxy settings for reliable data collection. Datacenter proxies (the default) are more than enough for this Actor.

## `maxConcurrency` (type: `integer`):

How many requests to run in parallel. Recommended: 4–8.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop",
    "biurko"
  ],
  "regionId": "",
  "condition": "all",
  "sortBy": "relevance",
  "startUrls": [],
  "maxItems": 100,
  "photoSize": "1000x1000",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Download every ad collected in this run (JSON, CSV, Excel).

## `runUrl` (type: `string`):

Open this run in the Apify Console.

## `title` (type: `string`):

Ad title

## `price` (type: `string`):

Numeric price

## `priceLabel` (type: `string`):

Formatted price (e.g. 1 850 zł)

## `currency` (type: `string`):

Currency (usually PLN)

## `previousPrice` (type: `string`):

Earlier price, when the seller lowered it

## `priceDropped` (type: `string`):

True when the current price is below the previous price

## `condition` (type: `string`):

New / Used

## `categoryType` (type: `string`):

Category type (e.g. electronics, automotive)

## `parameters` (type: `string`):

Category-specific item attributes (name → value)

## `description` (type: `string`):

Full ad description

## `city` (type: `string`):

City

## `district` (type: `string`):

District

## `region` (type: `string`):

Voivodeship

## `sellerName` (type: `string`):

Seller display name

## `isBusinessSeller` (type: `string`):

True = business, false = private

## `sellerRegisteredAt` (type: `string`):

When the seller joined OLX

## `hasPhone` (type: `string`):

Whether the seller published a phone number

## `photos` (type: `string`):

Image URLs

## `createdTime` (type: `string`):

When the ad was posted

## `url` (type: `string`):

Direct link to the ad

## `id` (type: `string`):

OLX offer ID

## `scrapedAt` (type: `string`):

ISO 8601 timestamp

# 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",
        "rower"
    ],
    "startUrls": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/olx-poland-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 = {
    "searchQueries": [
        "iphone",
        "rower",
    ],
    "startUrls": [],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/olx-poland-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 '{
  "searchQueries": [
    "iphone",
    "rower"
  ],
  "startUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/olx-poland-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Poland Classifieds Scraper – olx.pl Ads, Prices & Sellers",
        "description": "Scrape classified ads from OLX Poland (olx.pl): title, price, price drops, condition, all item attributes, seller, location and photos. Search by keyword with filters for price, region, condition and sort — or scrape specific listing URLs.",
        "version": "1.0",
        "x-build-id": "fjbBnXhpcAIlOYT8t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~olx-poland-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-olx-poland-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/haketa~olx-poland-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-olx-poland-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/haketa~olx-poland-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-olx-poland-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": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One keyword or phrase per line (in Polish for best results) — for example 'iphone', 'rower górski', 'sofa narożna'. Each keyword is searched and the results are merged. Leave blank to get an automatic sample.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regionId": {
                        "title": "Region (voivodeship)",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "7",
                            "8",
                            "9",
                            "10",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16"
                        ],
                        "type": "string",
                        "description": "Limit results to one Polish region. Leave as 'All Poland' to search the whole country.",
                        "default": ""
                    },
                    "priceMin": {
                        "title": "Min price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return ads at or above this price, in Polish złoty. Leave blank for no minimum."
                    },
                    "priceMax": {
                        "title": "Max price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return ads at or below this price, in Polish złoty. Leave blank for no maximum."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "all",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter by item condition.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "newest",
                            "price-asc",
                            "price-desc"
                        ],
                        "type": "string",
                        "description": "Order of the results.",
                        "default": "relevance"
                    },
                    "categoryId": {
                        "title": "Category ID (advanced)",
                        "type": "integer",
                        "description": "Optional. Restrict to a specific OLX category by numeric ID (you can read it from a category URL). Leave blank to search all categories."
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Optional. Paste OLX Poland URLs directly — either individual offer pages (…/d/oferta/…-IDxxxx.html) or search/category result pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of ads to collect in this run. Set to 0 for no limit. Note: OLX returns up to 1,000 results per individual search.",
                        "default": 0
                    },
                    "photoSize": {
                        "title": "Photo size",
                        "enum": [
                            "400x300",
                            "800x600",
                            "1000x1000"
                        ],
                        "type": "string",
                        "description": "Resolution used when building image URLs (width x height).",
                        "default": "1000x1000"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for reliable data collection. Datacenter proxies (the default) are more than enough for this Actor.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many requests to run in parallel. Recommended: 4–8.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
