# OLX.pl Car Scraper (`rastriq/olx-pl-scraper`) Actor

Scrape used car listings from OLX.pl, Poland's largest classifieds site: make, model, year, mileage, power, price in PLN, fuel, gearbox, city, voivodeship and dealer flag. Datacenter proxy, about 40-50 cars per page.

- **URL**: https://apify.com/rastriq/olx-pl-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 car listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## OLX.pl Car Scraper

Scrape used car listings from **OLX.pl**, the largest classifieds site in Poland. OLX.pl Car Scraper turns the *Samochody osobowe* (passenger cars) section into clean, structured data: make, model, year, mileage, engine power, asking price in PLN, fuel type, gearbox, city, voivodeship, dealer flag, photo and listing URL. No browser and no residential proxy: about 40-50 cars per page in a few seconds.

### 🚗 What is OLX.pl Car Scraper?

OLX.pl Car Scraper is an OLX scraper and unofficial OLX.pl API for the car section of the site. OLX.pl carries one of the largest second-hand car inventories in Poland, from private sellers and dealers alike, which makes it a reference point for used car prices in the Polish market.

The scraper reads the same JSON feed that the OLX.pl website uses to show its search results, so the values match what buyers see on the site, without parsing fragile HTML. Listings come newest first, which makes the actor a good fit for scheduled runs that track what has just been put up for sale.

Use it to:

- 📈 **Track used car prices in Poland** by make, model, year, mileage and region.
- 🏷️ **Benchmark your stock** against what private sellers and dealers are asking.
- 🔔 **Spot new listings early** with a scheduled run every hour or every day.
- 🧮 **Feed valuation models** and market research with fresh asking prices in PLN.
- 🗺️ **Compare regions**: every listing carries its city and voivodeship.
- 🏪 **Separate dealer and private supply** with the `is_professional` flag.

### 📋 What data does OLX.pl Car Scraper extract?

| Field | Description |
|---|---|
| 🆔 `id` | OLX.pl offer ID |
| 📝 `title` | Listing title as written by the seller |
| 🏭 `make` | Car brand (Audi, Volkswagen, Toyota...), from the OLX brand category |
| 🚘 `model` | Model label (A3, Passat, Corolla...) |
| 📅 `year` | Year of production |
| 🛣️ `km` | Mileage in km |
| 🐎 `hp` | Engine power in hp |
| 💰 `price` | Asking price |
| 💱 `currency` | ISO code, normally `PLN` |
| ⛽ `fuel_type` | `petrol`, `diesel`, `lpg`, `cng`, `hybrid`, `plugin-hybrid`, `electric`... |
| ⚙️ `gearbox` | `manual` or `automatic` |
| 📍 `city` | City of the listing |
| 🗺️ `region` | Voivodeship (Mazowieckie, Pomorskie...) |
| 🏪 `is_professional` | `true` when OLX flags the seller as a business |
| 🔗 `url` | Link to the offer on olx.pl |
| 🖼️ `img_url` | First listing photo (800x600) |
| 🌐 `source` | Always `olx.pl` |
| 🕒 `scraped_at` | UTC timestamp of extraction |

**How complete is the data?** In our latest test run (52 listings, 14 November 2026), make, model, year, mileage, price, fuel, gearbox, city and region were filled on every listing. `hp` was empty on about 10 % of listings, where the seller left engine power out, and `img_url` on one listing without photos.

**What is not there:**

- `model` is `null` when the seller picked "other model" (*inny*) on OLX.
- `make` is `null` if OLX files the car under a category that is not a brand. The scraper never guesses it from the title.
- **No seller names, phone numbers, user IDs or descriptions.** The scraper does not collect personal data.
- Fuel and gearbox use the English keys that OLX itself uses internally (`petrol`, `manual`...), so they are easy to filter.

### 🛠️ How to use OLX.pl Car Scraper

1. Open OLX.pl Car Scraper in Apify Console and click **Try for free**.
2. Optionally type a **Search text**, for example a brand such as `BMW`. Leave it empty for the whole car section.
3. Set **Max pages**. The prefill is 1 page, about 40-50 cars.
4. Keep the default **Proxy configuration** (Apify datacenter proxy). Residential proxy is not needed.
5. Click **Start**. A one-page run finishes in well under a minute.
6. Open the **Output** tab and download the results as JSON, CSV, Excel or XML, or read them through the Apify API.
7. To monitor the market, create a **Schedule** (for example every 6 hours) and connect it to Google Sheets, Make, Zapier or a webhook.

#### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `brand` | string | empty | Optional search text inside the car section, typically a brand. OLX matches it against the listing text, so a few unrelated cars can appear. |
| `max_pages` | integer | 3 | Result pages to scrape, newest first. About 40-50 cars per page; maximum 500. |
| `proxyConfiguration` | object | Apify datacenter proxy | Proxy settings. A blocked request is retried on a fresh proxy session. |

#### Input example

```json
{
  "brand": "BMW",
  "max_pages": 1,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### 📦 Output example

One item from a real run (14 November 2026):

```json
{
  "id": "1110147350",
  "title": "Audi A3 1,6 benzyna",
  "make": "Audi",
  "model": "A3",
  "year": 2006,
  "km": 195000,
  "hp": 110,
  "price": 14999,
  "currency": "PLN",
  "fuel_type": "petrol",
  "gearbox": "manual",
  "city": "Gniew",
  "region": "Pomorskie",
  "is_professional": false,
  "url": "https://www.olx.pl/d/oferta/audi-a3-1-6-benzyna-CID5-ID1d842q.html",
  "img_url": "https://ireland.apollo.olxcdn.com:443/v1/files/ee9a61pbp3u2-PL/image;s=800x600",
  "source": "olx.pl",
  "scraped_at": "2026-11-14T07:52:37.508530+00:00"
}
```

In Apify Console the **Overview** view shows title, make, model, year, km, price, fuel, gearbox, city, dealer flag and link; the **All fields** view adds power, region, photo, ID and timestamp.

### 💰 How much does it cost to scrape OLX.pl?

OLX.pl Car Scraper uses pay-per-event pricing. You pay only for results:

- **$1.00 per 1,000 car listings** saved to the dataset;
- **$0.005 per run start**.

No proxy or compute costs are added on top. Some examples:

| Run | Listings | Cost |
|---|---|---|
| Test run (1 page) | ~50 | about $0.06 |
| 10 pages | ~500 | about $0.51 |
| 100 pages | ~5,000 | about $5.01 |

With the $5 of free monthly credit on Apify's free plan you can scrape about 4,500 listings a month at no cost. Set a **maximum cost per run** in the run options if you want a hard cap on spending.

### ⚠️ Limits

- About 40-50 listings per page (40 regular ones plus the promoted listings OLX mixes in); `max_pages` goes up to 500. A promoted car can show up on more than one page, so deduplicate by `id` on long runs.
- When OLX has no more results, the run stops and keeps everything it found.
- OLX.pl sits behind a web application firewall. The scraper uses a browser-like connection and retries a blocked request up to 3 times on a fresh proxy session. If a page is still blocked, the run stops there and keeps the listings it already saved.
- A run that extracts nothing ends as **FAILED** instead of a green run with an empty dataset, so your schedules and integrations notice.
- Results reflect OLX.pl at run time. Prices and availability change quickly.
- Only the passenger car section is covered (no motorbikes, vans, parts or real estate).

### 🔗 Related actors

- [Willhaben Scraper](https://apify.com/rastriq/willhaben-scraper): used cars in Austria.
- [Marktplaats.nl Car Scraper](https://apify.com/rastriq/marktplaats-scraper): the largest Dutch marketplace.
- [Blocket Scraper](https://apify.com/rastriq/blocket-scraper): used cars in Sweden.

### ❓ FAQ

**Do I need a residential proxy to use OLX.pl Car Scraper?**
No. Our test runs used the default Apify datacenter proxy and no residential traffic. If a request is blocked, the scraper switches to a fresh proxy session by itself. The run's `SUMMARY` record in the key-value store shows how many requests were blocked.

**Can I filter by brand, price or region?**
You can narrow the run with the **Search text** field (for example a brand). Price, year and region filters are not in the input yet: filter the dataset after the run, or tell us in the Issues tab which filters you need.

**Why is `model` empty on some cars?**
The seller chose "other model" on OLX. The scraper reports `null` rather than guessing from the title.

**Is it legal to scrape OLX.pl?**
The scraper reads the public listing feed that OLX.pl's own robots.txt allows (`/api/v1/offers/`) and collects only listing data (car details, price, location and link), no personal data about sellers. You are responsible for how you use the data, including compliance with the GDPR and with OLX's terms of use. Read more in Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

**Can I use the output in Excel, Google Sheets or my own app?**
Yes. Export from the Output tab, use the Apify API, or connect an integration such as Google Sheets, Make, Zapier or a webhook.

**Something broke. What should I do?**
Open an issue in the **Issues** tab with the run ID. OLX.pl Car Scraper fails loudly when it extracts nothing, so a FAILED run usually means OLX changed something and we need to update the scraper.

# Changelog

This Actor's version history is a separate document: https://apify.com/rastriq/olx-pl-scraper/changelog.md

# Actor input Schema

## `brand` (type: `string`):

Optional full-text search inside the OLX.pl car section, for example a brand such as BMW. OLX matches it against the listing text, so a few unrelated cars can appear. Leave empty to scrape all cars.

## `max_pages` (type: `integer`):

Maximum result pages to scrape, newest listings first. Each page has about 40-50 cars (40 regular listings plus the promoted ones OLX mixes in). The run stops earlier when OLX has no more results.

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

Apify Proxy. The default datacenter proxy works; a blocked request is retried on a fresh proxy session. Residential proxy is not needed.

## Actor input object example

```json
{
  "brand": "BMW",
  "max_pages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped listings in the default dataset.

# 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 = {
    "max_pages": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/olx-pl-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 = {
    "max_pages": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "max_pages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/olx-pl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/olx-pl-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ysI7JV6qqv2diUJM5/builds/Dahq2fXUqxBsLZD7v/openapi.json
