# Poland OLX Classifieds Scraper (`jungle_synthesizer/poland-olx-classifieds-scraper`) Actor

Scrape listings from OLX.pl — Poland's largest classifieds marketplace. Extract price, location, seller details, and category for any category or keyword search. Covers all OLX categories: goods, automotive, real estate, jobs, and services.

- **URL**: https://apify.com/jungle\_synthesizer/poland-olx-classifieds-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## OLX Poland Classifieds Scraper

Scrape listings from [OLX.pl](https://www.olx.pl), Poland's largest classifieds marketplace with 25 million+ active listings. Returns price, location, seller details, condition, and category for any search across goods, automotive, real estate, jobs, and services.

---

### OLX Poland Classifieds Scraper Features

- Extracts listings across all OLX categories — goods, automotive, real estate, jobs, services, and more
- Filters by category slug (motoryzacja, elektronika, nieruchomosci, dom-i-ogrod, and others)
- Filters by keyword search — just pass in a search term
- Returns price in PLN with negotiable flag
- Returns city and region for every listing — no guessing where things are located
- No proxies required. OLX has a public REST API and this actor uses it directly, which keeps costs down

---

### What Can You Do With OLX Poland Data?

- **E-commerce researchers** — Track pricing trends across categories, compare new vs. used item prices, monitor market saturation for specific goods
- **Market entry analysts** — Assess consumer supply and demand signals in the Polish market before launching a product
- **Dropshippers and resellers** — Find arbitrage opportunities between regions or between OLX and retail prices
- **Data scientists** — Build training datasets for Polish-language NLP models on classified ad text
- **Recruiters** — Monitor the jobs category for competitor activity and compensation signals

---

### How OLX Poland Classifieds Scraper Works

1. Configure a category, keyword, or leave both empty to pull from the full feed
2. The scraper calls the OLX REST API with your filters and page size
3. Results paginate automatically until `maxItems` is reached — you don't manage the offset
4. Each record lands in the dataset with price, location, seller, and category fields normalized and ready to use

---

### Input

```json
{
  "maxItems": 100,
  "category": "elektronika",
  "keywords": "laptop"
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `maxItems` | integer | 10 | Maximum number of listings to return |
| `category` | string | *(empty)* | Category slug to filter results. See supported values below. |
| `keywords` | string | *(empty)* | Keyword search term. OLX text search across listing titles and descriptions. |

#### Supported Category Slugs

| Slug | Category |
|------|----------|
| `motoryzacja` | Automotive |
| `elektronika` | Electronics |
| `nieruchomosci` | Real Estate |
| `dom-i-ogrod` | Home & Garden |
| `moda` | Fashion |
| `praca` | Jobs |
| `sport-i-hobby` | Sports & Hobby |
| `dla-dzieci` | For Children |
| `zdrowie-i-uroda` | Health & Beauty |
| `uslugi` | Services |
| `firma-i-przemysl` | Business & Industry |

Leave `category` empty to scrape across all categories.

***

### OLX Poland Classifieds Scraper Output Fields

```json
{
  "listing_id": "1068314189",
  "platform": "olx",
  "title": "Rower Bianchi Via Nirone 7 rozmiar 55",
  "price_pln": 2800,
  "negotiable": true,
  "condition": "used",
  "seller_type": null,
  "seller_name": "Mateusz",
  "city": "Warszawa",
  "region": "Mazowieckie",
  "category_id": 1652,
  "category_type": "goods",
  "listed_at": "2026-04-20T18:15:25+02:00",
  "url": "https://www.olx.pl/d/oferta/rower-bianchi-CID767-ID1aixk1.html"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `listing_id` | string | Unique OLX listing ID |
| `platform` | string | Always `olx` |
| `title` | string | Listing title in Polish |
| `price_pln` | number | Price in Polish Zloty. Null when not set (e.g. job listings). |
| `negotiable` | boolean | Whether price is negotiable |
| `condition` | string | `new`, `used`, or null (not applicable for services/jobs) |
| `seller_type` | string | `private` or `business`. Null when seller doesn't disclose. |
| `seller_name` | string | Seller display name |
| `city` | string | City of the listing |
| `region` | string | Polish voivodeship (region) |
| `category_id` | number | OLX internal category ID |
| `category_type` | string | Category type: `goods`, `automotive`, `real_estate`, `job`, `services` |
| `listed_at` | string | ISO 8601 timestamp when listing was created |
| `url` | string | Direct URL to the listing on OLX.pl |

***

### 🔍 FAQ

#### How do I scrape OLX.pl listings?

OLX Poland Classifieds Scraper handles it via OLX's public REST API. Configure `maxItems`, optionally add a category slug or keyword, and run. You get structured JSON output without managing pagination or parsing HTML.

#### How much does the OLX Poland Classifieds Scraper cost to run?

The scraper charges $0.001 per record plus a $0.10 start fee. A run of 1,000 listings costs around $1.10. No proxy costs — OLX doesn't require them.

#### Can I filter by city or region?

Not directly — OLX's public API doesn't expose geographic filtering as a standalone parameter. Filter by category and keyword, then post-filter by the `city` or `region` fields in your dataset.

#### Does OLX Poland Classifieds Scraper require proxies?

No. OLX.pl has a public REST API that's accessible from Apify's cloud infrastructure without residential proxies. That's one fewer cost to worry about.

#### What's the maximum number of listings I can scrape?

OLX's API surfaces up to 1,000 results per query. For broader coverage across specific categories or date ranges, run multiple actors with different category or keyword inputs and combine the datasets downstream.

#### Are phone numbers included in the output?

No. OLX protects phone numbers behind a click-to-reveal gate that requires user authentication. The `seller_name` and `seller_type` fields are available; actual phone numbers are not.

***

### Need More Features?

Need custom fields, additional category support, or otoMoto vehicle data? [File an issue](https://console.apify.com/actors/ZpYdP5PchQkAEpQes/issues) or get in touch.

### Why Use OLX Poland Classifieds Scraper?

- **No proxies, no extra cost** — OLX serves a public API, so you pay for records only, not bandwidth
- **Structured output with normalized fields** — price extracted from OLX's dynamic params array, condition and negotiable flag decoded, location split into city and region
- **Covers the full OLX catalog** — from used clothing to commercial vehicles to apartment rentals, all 25M+ listings from a single actor

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

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

Maximum number of listings to scrape. Use a small number for testing.

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

OLX category slug to filter listings (e.g. 'motoryzacja', 'elektronika', 'nieruchomosci'). Leave empty for all categories.

## `keywords` (type: `string`):

Search keywords to filter listings (e.g. 'laptop', 'rower'). Leave empty for no keyword filter.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
    "category": "",
    "keywords": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/poland-olx-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
    "category": "",
    "keywords": "",
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/poland-olx-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10,
  "category": "",
  "keywords": ""
}' |
apify call jungle_synthesizer/poland-olx-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Poland OLX Classifieds Scraper",
        "description": "Scrape listings from OLX.pl — Poland's largest classifieds marketplace. Extract price, location, seller details, and category for any category or keyword search. Covers all OLX categories: goods, automotive, real estate, jobs, and services.",
        "version": "0.1",
        "x-build-id": "SLv0QdMtodzf4AHyJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~poland-olx-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-poland-olx-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/jungle_synthesizer~poland-olx-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-poland-olx-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/jungle_synthesizer~poland-olx-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-poland-olx-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",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. Use a small number for testing.",
                        "default": 10
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "OLX category slug to filter listings (e.g. 'motoryzacja', 'elektronika', 'nieruchomosci'). Leave empty for all categories."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Search keywords to filter listings (e.g. 'laptop', 'rower'). Leave empty for no keyword filter."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
