# OLX.pl Used Car Listings by Make & Fuel Type (`vexaloom-labs/olx-pl-used-car-listings-by-make-and-fuel-type`) Actor

Search olx.pl for used cars in Poland by keyword, fuel type, gearbox, condition, year, and price range. Get make, model, year, price in PLN, mileage, location, and photos per listing.

- **URL**: https://apify.com/vexaloom-labs/olx-pl-used-car-listings-by-make-and-fuel-type.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

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

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 Used Car Listings by Make & Fuel Type

OLX.pl is Poland's biggest classifieds marketplace. This actor pulls used-car listings from its passenger-car section and returns one structured row per offer, either by searching with vehicle filters or by reading listing pages you paste in.

### Two ways to run it

- **Search listings** — combine a keyword with make, model, fuel, gearbox, condition, body, colour, drive, country of origin, seller type, region, year, price, mileage and engine-size/power ranges. Sort by newest, price or relevance.
- **Read listing URLs** — paste olx.pl listing links or numeric OLX listing IDs. The actor reads each listing page (or resolves the ID through OLX's search API) and returns the same row shape.

No account, cookie, login, API key or proxy setup is needed.

### What you get per listing

| Field | Type | Meaning |
|---|---|---|
| `listingId` | string | OLX offer ID |
| `title` | string | Listing headline |
| `slug` | string | URL slug of the offer |
| `listingUrl` | string | Absolute olx.pl link |
| `make` | string | Manufacturer, mapped from OLX's car category |
| `model` | string | Model as listed (e.g. Corolla, Octavia, C Klasa) |
| `year` | integer | Model/production year |
| `pricePln` | integer | Asking price in Polish zloty |
| `currency` | string | Price currency (PLN on olx.pl) |
| `priceNegotiable` | boolean | Present when the seller accepts negotiation |
| `mileage` | string | Odometer as OLX displays it (e.g. "245 000 km") |
| `mileageKm` | integer | Odometer in kilometres |
| `fuelType` / `fuelTypeCode` | string | Display name and OLX key (petrol, diesel, lpg, cng, electric, plugin-hybrid) |
| `gearbox` / `gearboxCode` | string | Display name and OLX key (manual, automatic) |
| `engineSize` / `engineSizeCc` | string / integer | Displacement, display value and cm³ |
| `enginePower` / `enginePowerHp` | string / integer | Power, display value and horsepower |
| `bodyType` / `bodyTypeCode` | string | Body style |
| `color` / `colorCode` | string | Exterior colour |
| `doorCount` | string | Door count, when OLX exposes it |
| `condition` / `conditionCode` | string | Damage condition (notdamaged / damaged) |
| `drive` / `driveCode` | string | Driven wheels / 4x4 type |
| `steeringSide` / `steeringSideCode` | string | Left- or right-hand drive |
| `countryOrigin` / `countryOriginCode` | string | Declared import country |
| `vin` | string | VIN, when the seller publishes it |
| `city`, `region`, `district` | string | Seller location |
| `latitude`, `longitude` | number | Offer map coordinates |
| `sellerId`, `sellerName` | string | Seller identity |
| `sellerType` | string | OLX seller type when present |
| `sellerCreatedAt`, `sellerLastSeenAt` | string | Account timestamps |
| `sellerIsOnline` | boolean | Present when the seller is online |
| `isBusiness` | boolean | Business/dealer listing |
| `isPromoted`, `isHighlighted`, `isUrgent` | boolean | OLX promotion flags |
| `phoneAvailable`, `chatAvailable` | boolean | Contact options offered by OLX |
| `shopSubdomain` | string | Dealer shop subdomain |
| `listingStatus` | string | OLX offer status (usually `active`) |
| `description` | string | Full description with HTML removed |
| `imageUrl` | string | Primary photo URL; search/ID rows are sized 1000x700, listing-page rows keep OLX's size |
| `photoUrls` | array | Up to 20 photo URLs |
| `createdAt`, `refreshedAt`, `validToAt` | string | Offer timestamps |
| `recordType` | string | Always `carListing` |
| `dataSource` | string | `search` or `details` |
| `scrapedAt` | string | UTC scrape timestamp |

Fields OLX does not publish for a particular car are omitted, never returned as null or an empty string.

### Inputs

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | select | `search` | `search` or `details` |
| `listingUrls` | array | – | Details mode: olx.pl links or numeric IDs |
| `query` | string | – | Free-text keywords |
| `make` | select | any | 113 OLX car makes |
| `model` | string | – | Model name; matched to OLX's model list for the chosen make |
| `fuelType` | select | any | petrol, diesel, lpg, cng, electric, plugin-hybrid |
| `transmission` | select | any | manual, automatic |
| `condition` | select | any | not damaged, damaged |
| `bodyType` | select | any | 10 OLX body styles |
| `color` | select | any | 10 OLX colours |
| `drive` | select | any | front, rear or three 4x4 types |
| `countryOrigin` | select | any | 38 import countries |
| `steeringSide` | select | any | left or right |
| `ownerType` | select | any | private or business |
| `region` | select | all Poland | 16 voivodeships |
| `minYear`, `maxYear` | integer | – | 1900–2030 |
| `minPrice`, `maxPrice` | integer | – | PLN |
| `minMileage`, `maxMileage` | integer | – | kilometres |
| `minEngineSize`, `maxEngineSize` | integer | – | cm³ |
| `minEnginePower`, `maxEnginePower` | integer | – | hp |
| `sortBy` | select | `created_at:desc` | relevance, newest (last refresh), cheapest, most expensive |
| `includePromoted` | boolean | true | Set false to drop top/promoted ads |
| `maxItems` | integer | 20 | 1–5,000 unique listings |

Inverted ranges (a minimum above the maximum) are swapped automatically.

### Examples

Diesel automatic Toyotas, 2015–2020, in Mazowieckie, cheapest first:

```json
{
  "mode": "search",
  "make": "toyota",
  "fuelType": "diesel",
  "transmission": "automatic",
  "minYear": 2015,
  "maxYear": 2020,
  "region": "mazowieckie",
  "sortBy": "filter_float_price:asc",
  "maxItems": 100
}
```

Electric cars under 80,000 PLN:

```json
{
  "mode": "search",
  "fuelType": "electric",
  "maxPrice": 80000,
  "maxItems": 50
}
```

Read two specific offers (one URL, one numeric ID):

```json
{
  "mode": "details",
  "listingUrls": [
    "https://www.olx.pl/d/oferta/suzuki-swift-1-3-benzyna-CID5-ID1absuK.html",
    "1104626015"
  ]
}
```

### How pagination works

OLX returns at most 1,000 listings for a single search query. When `maxItems` is above that, the actor does not give up: it splits the search into narrower year ranges, then price ranges, until each slice fits inside OLX's window, and de-duplicates the rows by listing ID. This reaches up to 5,000 unique listings. If a single year-and-price slice still exceeds 1,000, the run says so in its status message; add another filter to narrow that slice.

### Data source and scope

The actor reads OLX's public search JSON (`/api/v1/offers/`) and the server-rendered listing pages. It is limited to the olx.pl passenger-car category; other OLX countries and non-car categories are out of scope. It is an independent tool, not affiliated with OLX Group.

### FAQ

**Do I need cookies, an account or an API key?**
No. Every field comes from public OLX pages and requires no login.

**Why is a field missing on some rows?**
Sellers do not fill every attribute. OLX also hides the VIN on many offers. Missing values are omitted.

**What does "condition" mean?**
OLX reports whether a car is damaged or not damaged. The legacy values `used` and `new` are still accepted and map to `notdamaged`.

**Will my old task inputs still work?**
Yes. `gearbox` maps to `transmission`, `fuelType: hybrid` maps to OLX's CNG/hybrid key, `condition: used|new` maps to not damaged, `urls`/`startUrls` open details mode, and `sort` maps to `sortBy`.

**Are promoted ads included?**
Yes by default, and they are flagged with `isPromoted`. OLX inserts promoted ads into result slots, so they count toward `maxItems` and can appear in any sort order. Set `includePromoted` to false for organic-only, strictly sorted results.

**How is "newest first" ordered?**
OLX ranks bumped/refreshed offers, so `created_at:desc` returns the most recently refreshed listings first. `refreshedAt` is that refresh time; `createdAt` is the original creation date.

**Can I combine filters?**
Yes — every vehicle filter, range, region and sort order can be combined in one run.

**Are prices always PLN?**
Listings on olx.pl are priced in PLN; `currency` confirms the value on each row.

**Why did a run return fewer rows than I asked for?**
Either OLX had no more matches, or a single year-and-price slice hit OLX's 1,000-result ceiling. The status message says which case applied.

# Actor input Schema

## `mode` (type: `string`):

Search listings by filters, or read individual listing pages from URLs / IDs.

## `listingUrls` (type: `array`):

Detail/URL mode only. Paste olx.pl car listing links, or numeric OLX listing IDs. One per line.

## `query` (type: `string`):

Free-text keywords (e.g. 'Toyota Corolla', 'BMW 3'). Leave empty to browse all cars.

## `make` (type: `string`):

Car manufacturer. Leave empty for all makes.

## `model` (type: `string`):

Model name inside the selected make (e.g. Corolla, Octavia, C Klasa). Leave empty for all models.

## `fuelType` (type: `string`):

Fuel or powertrain type.

## `transmission` (type: `string`):

Transmission type.

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

OLX technical condition: not damaged or damaged.

## `bodyType` (type: `string`):

Car body style.

## `color` (type: `string`):

Exterior colour.

## `drive` (type: `string`):

Driven wheels / 4x4 type.

## `countryOrigin` (type: `string`):

Country the car was imported from, as declared by the seller.

## `steeringSide` (type: `string`):

Left- or right-hand drive.

## `ownerType` (type: `string`):

Private seller or business/dealer.

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

Polish voivodeship to search in. Leave empty for all of Poland.

## `minYear` (type: `integer`):

Oldest model year to include.

## `maxYear` (type: `integer`):

Newest model year to include.

## `minPrice` (type: `integer`):

Minimum listing price in Polish zloty.

## `maxPrice` (type: `integer`):

Maximum listing price in Polish zloty.

## `minMileage` (type: `integer`):

Minimum odometer reading in kilometres.

## `maxMileage` (type: `integer`):

Maximum odometer reading in kilometres.

## `minEngineSize` (type: `integer`):

Minimum engine displacement in cubic centimetres.

## `maxEngineSize` (type: `integer`):

Maximum engine displacement in cubic centimetres.

## `minEnginePower` (type: `integer`):

Minimum engine power in horsepower.

## `maxEnginePower` (type: `integer`):

Maximum engine power in horsepower.

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

Order of the returned listings.

## `includePromoted` (type: `boolean`):

Include paid/promoted OLX listings alongside organic results.

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

Maximum number of unique listings to return. OLX exposes up to 1,000 per query; larger limits are split across year/price slices automatically.

## Actor input object example

```json
{
  "mode": "search",
  "listingUrls": [],
  "query": "Toyota",
  "make": "",
  "fuelType": "",
  "transmission": "",
  "condition": "",
  "bodyType": "",
  "color": "",
  "drive": "",
  "countryOrigin": "",
  "steeringSide": "",
  "ownerType": "",
  "region": "",
  "sortBy": "created_at:desc",
  "includePromoted": true,
  "maxItems": 3
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing every scraped car listing. Empty fields are omitted, never null.

# 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 = {
    "mode": "search",
    "listingUrls": [],
    "query": "Toyota",
    "make": "",
    "fuelType": "",
    "transmission": "",
    "condition": "",
    "bodyType": "",
    "color": "",
    "drive": "",
    "countryOrigin": "",
    "steeringSide": "",
    "ownerType": "",
    "region": "",
    "sortBy": "created_at:desc",
    "includePromoted": true,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/olx-pl-used-car-listings-by-make-and-fuel-type").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 = {
    "mode": "search",
    "listingUrls": [],
    "query": "Toyota",
    "make": "",
    "fuelType": "",
    "transmission": "",
    "condition": "",
    "bodyType": "",
    "color": "",
    "drive": "",
    "countryOrigin": "",
    "steeringSide": "",
    "ownerType": "",
    "region": "",
    "sortBy": "created_at:desc",
    "includePromoted": True,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/olx-pl-used-car-listings-by-make-and-fuel-type").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 '{
  "mode": "search",
  "listingUrls": [],
  "query": "Toyota",
  "make": "",
  "fuelType": "",
  "transmission": "",
  "condition": "",
  "bodyType": "",
  "color": "",
  "drive": "",
  "countryOrigin": "",
  "steeringSide": "",
  "ownerType": "",
  "region": "",
  "sortBy": "created_at:desc",
  "includePromoted": true,
  "maxItems": 3
}' |
apify call vexaloom-labs/olx-pl-used-car-listings-by-make-and-fuel-type --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/olx-pl-used-car-listings-by-make-and-fuel-type"
        }
    }
}
```

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/PPeaNeinzhQGBNDFu/builds/B1EwcpcWEih0uOWU0/openapi.json