DEV Community: Norbert Sobala

How to scrape OLX.pl car listings by make, year and mileage with Python

Norbert Sobala — Tue, 20 Oct 2026 07:29:19 +0000

OLX.pl is where a large share of Poland's used cars get listed, by dealers and private owners alike. The site has good filters, but there is no export button, and comparing 200 listings by hand gets old fast. This guide uses the OLX Car Scraper Poland on Apify to turn a filtered car search into a table you can open in Excel or load into pandas.

My test search: Toyota Corolla, passenger cars, model year 2018 or newer, whole country, capped at 40 listings. Everything below comes from that dataset.

What you get per listing

The field names are in Polish because the actor targets the Polish market. Here is what they mean:

Field	Meaning	Example from my run
`title`, `url`	Listing title and link	Toyota Corolla 1.5 VVT-i 125KM Comfort
`marka`, `model`	Make, model	Toyota, Corolla
`rocznik`	Model year	2022
`przebiegKm`	Mileage in km	180000
`cena`, `waluta`	Price, currency	52500, PLN
`paliwo`	Fuel (Benzyna = petrol, CNG i Hybryda = hybrid)	Benzyna
`skrzynia`, `naped`	Gearbox, drive	Manualna, Na przednie koła
`pojemnoscCm3`, `mocKm`	Engine size (cm³), power (hp)	1490, 125
`typNadwozia`, `kolor`, `stan`	Body type, colour, damaged or not	Sedan, Biały, Nieuszkodzony
`krajPochodzenia`	Country of origin	Polska
`miasto`, `wojewodztwo`, `gpsLat`, `gpsLon`	City, region, coordinates	Wieliczka, Małopolskie
`sprzedawcaTyp`	Seller type (Prywatny = private, Komis / Firma = dealer)	Komis / Firma
`dataDodania`, `dataOdswiezenia`	Posted and refreshed timestamps	2026-10-07T18:01:47+02:00
`glowneZdjecie`, `zdjecia`, `opis`	Main photo, all photos, description (HTML)

There is also sprzedawcaNazwa, the seller's display name. For private sellers that is a person's name, so treat it carefully (more on that at the end).

What 40 Corollas looked like

Prices went from 36,900 PLN to 141,900 PLN, median 78,195 PLN. Median mileage was about 90,000 km.
25 cars were hybrids, 11 petrol, 3 LPG and 1 diesel. All 25 hybrids were automatics, and every non-hybrid had a manual gearbox.
34 listings came from dealers and 6 from private sellers.
6 listings were brand new 2026 cars with 1 to 5 km on the clock, all from dealers. They pull the averages up, so filter them out if you want used-car prices.
27 of the 40 cars were in the Mazowieckie region (Warsaw and around). I did not set a city, so that is just where the supply sits for this query.

Comparing like with like is where a table beats scrolling. For model years 2018 to 2023 only, the 14 hybrids had a median price of 79,370 PLN against 58,450 PLN for the 10 petrol cars, at similar median mileage (about 120,000 vs 115,000 km). That is roughly a 21,000 PLN premium for the hybrid in this small sample. Forty rows won't settle a market question. It does show what you can answer in two minutes once the data is in a DataFrame.

Option 1: no code

Open the actor page and click Try for free.
Pick a Kategoria (category): passenger cars, motorcycles, trucks, vans, trailers or parts.
Choose one or more Marki (makes). Multi-select works, so BMW and Audi can go in one run.
Type Modele (models) if you want them, for example Golf, Passat.
Set filters: price, year, mileage, fuel, gearbox, city with a radius.
Set Maks. liczba ogłoszeń (max listings). I used 40. Click Start and export from the Storage tab as CSV, Excel or JSON.

The form groups filters into sections, so you never have to build OLX URLs yourself:

Option 2: Python with apify-client and pandas

pip install apify-client pandas

Grab your API token from Settings → API & Integrations in the Apify console and keep it in an environment variable.

import os
import pandas as pd
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run_input = {
    "kategoria": "samochody-osobowe",
    "marki": ["toyota"],
    "modele": ["Corolla"],
    "rocznikOd": 2018,
    "maxLiczbaOgloszen": 40,
}

run = client.actor("liveclaude/olx-motoryzacja-pl").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items
df = pd.DataFrame(items)

# Leave out new cars and the seller name column
used = df[df["przebiegKm"] > 100].drop(columns=["sprzedawcaNazwa"], errors="ignore")

summary = (
    used[used["rocznik"] <= 2023]
    .groupby("paliwo")
    .agg(listings=("cena", "size"),
         median_price=("cena", "median"),
         median_km=("przebiegKm", "median"))
)
print(summary)

cols = ["title", "rocznik", "przebiegKm", "cena", "paliwo",
        "skrzynia", "mocKm", "miasto", "sprzedawcaTyp", "url"]
used[cols].sort_values("cena").to_csv("olx_corolla.csv", index=False)

call() waits for the run to end. For runs with thousands of listings, start() plus a webhook is cleaner.

Input options worth knowing

Category and makes. kategoria takes samochody-osobowe, motocykle, ciezarowe, dostawcze, przyczepy-naczepy or czesci. marki is a list of lowercase slugs like bmw or volkswagen, and modele is free text.

Ranges. cenaOd/cenaDo (price in PLN), rocznikOd/rocznikDo (year), przebiegOd/przebiegDo (km), pojemnoscOd/pojemnoscDo (cm³), mocOd/mocDo (hp).

Specs. paliwa (fuel list), skrzynia (manual or automatic), naped (front, rear or one of the AWD variants), typNadwozia, kolor, and stan to keep or drop damaged cars.

Location. miasto plus promienKm (0 to 100 km) for a radius search around a city.

Seller and freshness. typSprzedawcy filters to private or business. opublikowaneW limits to listings from the last 24 hours, 7 days or 30 days. tylkoZeZdjeciem keeps only listings with photos.

Volume. maxLiczbaOgloszen defaults to 500 per run. uzyjProxy turns on Apify proxy rotation if you run large jobs. advancedUrls accepts raw OLX search URLs when a filter is missing from the form.

Scheduling: alerts for new listings

The most practical feature is monitorNowe. With it on, each run returns only listings that were not there last time. wykrywajZmianyCen (on by default) also flags price drops on cars you already saw. Here is an input a dealer could schedule every 30 minutes:

{
  "kategoria": "samochody-osobowe",
  "marki": ["bmw", "audi"],
  "cenaDo": 80000,
  "rocznikOd": 2015,
  "przebiegDo": 150000,
  "miasto": "Warszawa",
  "promienKm": "50",
  "monitorNowe": true
}

Create the schedule in the Apify console, then send results to Google Sheets, Slack, Make, Zapier or n8n, or to your own endpoint with a webhook. You can also call the actor from Claude, ChatGPT or Cursor through the Apify MCP server.

Pricing

Pay per event. Per 1,000 events at the current price list:

Event	Free	Bronze	Silver	Gold
Listing scraped	$6	$5	$4	$3
New listing found (monitoring)	$12	$10	$8	$6
Price change detected	$6	$5	$4	$3

Each run also has a $0.05 start fee. New users get their first 100 listings free, which covers a test like mine twice over.

Responsible use

The actor reads public OLX listings. Private sellers are people, and their names and anything in a free-text description can be personal data under GDPR. Drop sprzedawcaNazwa unless you have a lawful reason to keep it, do not build contact lists from private listings, and check that your use fits OLX.pl's terms. Keep run frequency sensible: every 30 minutes for a narrow search is plenty.

This tutorial was written with AI assistance and checked by the author. All numbers come from a real run of the scraper.

How to scrape Allegro.pl offers, sellers and prices with Python and pandas

Norbert Sobala — Tue, 20 Oct 2026 07:29:01 +0000

Allegro is the biggest marketplace in Poland, and if you sell there (or compete with people who do) you end up checking prices by hand far too often. This guide shows how to pull Allegro search results into a spreadsheet or a pandas DataFrame with the Allegro Product Scraper on Apify. No login, no browser automation on your side.

For this post I ran it on one search phrase, ekspres do kawy (coffee machine), sorted by popularity, new items only, capped at 40 offers. The run finished in about 75 seconds. Every number below comes from that dataset.

What you get per offer

The default mode reads the search listing only, which is fast and cheap. One row per offer:

Field	What it holds	Example from my run
`title`	Offer title	Ekspres ciśnieniowy automatyczny Philips ...
`price` / `currency`	Current price	943.00 PLN
`originalPrice`, `discountPercent`	Price before discount (lowest of last 30 days), if shown	249.00 → 199.00
`priceWithDelivery`, `deliveryTime`	Cheapest price incl. shipping and the delivery promise	957.99, "dostawa jutro"
`smart`	Allegro Smart! free delivery eligible	true
`lowestPriceGuarantee`	"Gwarancja najniższej ceny" badge	true
`promoted`	Sponsored placement	true
`recentBuyers`	"X people bought recently" counter	192
`superSeller`, `sellerRating`, `sellerIsCompany`	Seller badges and rating	true, 99.5, true
`productOffersCount`	How many sellers offer the same catalogue product	51
`productRating`, `productReviewsCount`	Product reviews	4.95, 544
`parameters`, `mainImage`, `images`	Key specs and photos

Switch on Full offer details (scrapeDetails: true) and the scraper also opens each offer page. Then you get EAN/GTIN, brand, stock, units sold in the last 30 days, the full parameter table, description, warranty, category path and the rating distribution.

What 40 offers told me

A quick look at the raw data before any cleaning:

Prices ranged from 17.99 PLN to 1,949 PLN, median 232.76 PLN. That median is low because a popularity sort mixes in accessories. 11 of the 40 rows were mats, gaskets, descaler or toy coffee machines for kids. Filtering titles down to real machines left 29 rows with a median of 419 PLN.
36 of 40 offers were promoted. On a popularity-sorted first page, sponsored slots are most of what you see. If you want organic results, set includePromoted to false.
38 offers were Smart! and only 7 had free delivery for everyone. priceWithDelivery is the column to compare if your customers do not have Smart!.
18 offers carried the Lowest Price Guarantee badge, all of them actual machines.
The median machine had 22 competing sellers for the same catalogue product (productOffersCount). One cheap automatic machine had 320.
Seller ratings sat between 94.8% and 100%.

That last point about competing sellers is where the scraper gets useful for pricing work. If a product has 50 sellers, you probably want all 50 prices, which is what the EAN mode below is for.

Option 1: no code

Open the actor page and click Try for free. A free Apify account works.
Pick the marketplace: Allegro.pl, .cz or .sk. Currency follows (PLN, CZK, EUR).
Add one or more Search phrases. You can also paste Allegro URLs: a category, a seller shop (/uzytkownik/...), single offers or product pages. Or paste EAN codes.
Set Max. offers per input. I used 40.
Optional filters: min/max price, condition, sort order, Smart! only, hide promoted.
Click Start, wait, then export from the Storage tab to Excel, CSV or JSON.

Here is the input form so you can see where everything sits:

Option 2: Python with apify-client and pandas

Install the two packages:

pip install apify-client pandas

Then run the actor and load the results. Your API token is under Settings → API & Integrations in the Apify console. Keep it in an environment variable.

import os
import pandas as pd
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run_input = {
    "marketplace": "pl",
    "searchQueries": ["ekspres do kawy"],
    "maxItemsPerInput": 40,
    "condition": "new",
    "sortOrder": "popularity",
}

run = client.actor("liveclaude/allegro-seller-scraper").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items
df = pd.DataFrame(items)

# Drop accessories that a popularity sort pulls in
junk = "mata|uszczel|odkamien|podkładk|dla dzieci|zabawka"
machines = df[~df["title"].str.contains(junk, case=False)]

cols = ["title", "price", "priceWithDelivery", "smart", "promoted",
        "recentBuyers", "productOffersCount", "lowestPriceGuarantee", "url"]
print(machines[cols].sort_values("recentBuyers", ascending=False).head(10))
print("median price:", machines["price"].median())

machines[cols].to_csv("allegro_coffee_machines.csv", index=False)

The call() method blocks until the run ends, so for big jobs you may prefer start() and polling.

The input options that matter

Ways in. searchQueries, startUrls and eans can all go into one run. Category URLs are good for whole-segment exports. A seller shop URL gives you a competitor's full catalogue.

EAN mode. Put barcodes in eans and the actor returns every seller of that product, ranked by price, with lowest, highest and average price. maxOffersPerProduct (default 50) caps sellers per product. allSellersForProducts does the same for product URLs.

{ "eans": ["195949036842", "5702017584072"], "maxOffersPerProduct": 50 }

Output shape. outputFormat: "offers" gives one row per offer. "products" groups them.

More than 6,000 results. Allegro stops at 100 pages per search. With deepPagination on (the default), the actor splits large searches into price bands so a full category export still works.

Hidden discounts. detectHiddenDiscounts shows, for Lowest Price Guarantee offers, the price the seller set and how much Allegro covers (realSellerPrice, hiddenDiscount). No extra charge.

Seller company data. sellerCompanyDetails adds company name, NIP, KRS and address from the seller's public business info.

Images. downloadImages with maxImages (default 5) stores the files, handy if you are building a product feed.

Scheduling and integrations

For price monitoring, turn on onlyChanges and give the job a monitorId, for example "coffee-machines". Each scheduled run then returns only new offers and changed prices, with previousPrice and priceChange fields. Unchanged offers are not charged.

{
  "startUrls": ["https://allegro.pl/kategoria/smartfony-i-telefony-komorkowe-165"],
  "onlyChanges": true,
  "monitorId": "smartphones",
  "maxItemsPerInput": 5000
}

Add a schedule in the Apify console (daily at 6:00 is a sane start). Results can flow into Google Sheets, Make, Zapier, n8n or Slack, or a webhook can ping your own service when a run finishes. The actor also works from Claude, ChatGPT or Cursor through the Apify MCP server.

Pricing

Pay per event, platform usage included. Per 1,000 offers, at the current price list:

Event	Free	Starter	Scale	Business
Offer from listing	$3.50	$3.20	$3.00	$2.80
Offer with full details	$6.00	$5.50	$5.00	$4.50

Monitoring, hidden-discount detection and image download cost nothing extra. At the Free tier rate, my test run (36 charged listing events) works out to about 13 cents.

Responsible use

The actor reads public offer pages only. Business sellers' company data is information they publish on Allegro themselves. Some Allegro sellers are private persons, though, and their logins can be personal data under GDPR. If you store or share the dataset, drop or pseudonymise sellerLogin for non-company sellers (sellerIsCompany tells you which). Keep request volumes reasonable and check Allegro's terms for your use case.

This tutorial was written with AI assistance and checked by the author. All numbers come from a real run of the scraper.

How to scrape Glassdoor jobs and salaries into Excel or Python (no login, no API key)

Norbert Sobala — Mon, 19 Oct 2026 21:31:36 +0000

Glassdoor is one of the few job boards that shows a salary range next to the job: either the employer's own or a Glassdoor estimate. It also shows the company rating. That makes the data useful beyond job hunting. Two common uses:

Salary benchmarking. What do product managers in Berlin actually get offered?
Sales and recruiting. Which companies are hiring right now, and for which roles? A company opening five sales positions this month is usually a company with budget.

Glassdoor has no public API for this, and logged-out visitors only see the first page of results. This guide uses a ready-made scraper on Apify that handles both problems. You can get the data without writing any code, or call it from Python.

What you get

Every job comes back as one clean record:

Field	Example
`title`	Product Manager (m/w/d)
`company`	Lokalleads GmbH
`location` / `country`	Berlin, Germany
`salaryMin` / `salaryMax`	60000 / 60000
`salaryCurrency` / `salaryPeriod`	EUR / year
`salaryIsEstimate`	false (set by the employer, not a Glassdoor estimate)
`salaryYearlyMinEur`	60000 (normalised to EUR per year, so you can compare countries)
`remote`	hybrid
`easyApply`	true
`postedAt`	2026-10-14

You can also turn on:

Full descriptions, which add the whole job text, employment type and industry.
Company signals, which add one summary record per company: open roles, jobs posted in the last 7 days, remote share and median salary. This is handy for spotting companies that are scaling up.

Option 1: no code (2 minutes)

Open Glassdoor Jobs Scraper and click Try for free.
Type your search, e.g. product manager, choose a location (Berlin) and a country.
Optionally tick Only jobs with salary, Remote only, or a date range such as Posted in the last 7 days.
Click Start. When the run finishes, export to Excel, CSV or JSON, or send the data straight to Google Sheets.

When we ran "product manager" in Berlin, 10 jobs came back in under a minute. Two of them had a salary published by the employer: €60,000 and €72,000 a year. The employers ranged from small agencies to Bundesdruckerei and Berliner Sparkasse. How many listings carry a salary depends on the country. Several US states require pay ranges in job ads, so US searches usually return far more numbers than German ones. If you only want listings with pay, tick Only jobs with salary.

Option 2: Python

pip install apify-client pandas

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")  # Console → Settings → API & Integrations

run = client.actor("liveclaude/glassdoor-jobs-scraper").call(run_input={
    "searchQueries": ["data analyst", "data engineer"],
    "locations": ["London"],
    "country": "gb",
    "postedWithin": "week",
    "onlyWithSalary": True,
    "maxJobsPerSearch": 200,
})

jobs = list(client.dataset(run["defaultDatasetId"]).iterate_items())
df = pd.DataFrame(jobs)

# median advertised salary per search, in EUR per year
print(df.groupby("searchQuery")[["salaryYearlyMinEur", "salaryYearlyMaxEur"]].median())

df.to_excel("glassdoor_jobs.xlsx", index=False)

The salaryYearlyMinEur and salaryYearlyMaxEur fields are already converted to euros per year. That lets you compare London with Sydney or New York without converting anything yourself.

Keep it fresh automatically

Add a Schedule in Apify, for example every Monday at 8:00, and turn on Only new jobs. Each run then returns only listings you haven't seen before. From there you can push new jobs to Slack or email as alerts, or append them to a Google Sheet and keep a running salary tracker. Make, Zapier and n8n work too if you want the data in a CRM.

What does it cost?

You pay per result: $0.50 per 1,000 jobs, and $3 per 1,000 if you also want full descriptions. Platform costs are included. A weekly tracker of a few hundred jobs costs cents. Apify's free plan includes monthly credit, which is enough to try it.

A note on responsible use

The scraper collects only what Glassdoor shows publicly to logged-out visitors. It does not log in and does not collect reviews written by individuals. If you store data about people (for example, recruiters' names in descriptions), treat it according to GDPR or your local law.

Questions or a missing field? Open an issue on the Actor page. Requests usually ship within a few days.

This tutorial was written with AI assistance and checked by the author. All numbers come from a real run of the scraper.