DEV Community: Norbert Sobala

How to compare all sellers of one Allegro product by price and condition in Python

Norbert Sobala — Mon, 02 Nov 2026 08:36:02 +0000

Allegro groups offers for the same item under one catalogue product page. That page is where sellers fight on price, and it is also where a quick glance misleads you: new units, ex-display stock, used phones and damaged ones all sit in one list. If you do repricing or keep an eye on distributors, you want that list as a table you can filter.

This guide uses the Allegro Price Comparison actor on Apify. You paste a product or offer link and it returns every seller offer for that product. I ran it this morning on one product, the black iPhone 15 256 GB, and every number below comes from that run.

What the run returned

Input was a single product URL with topNOffers set to 25. The log reported 57 offers on the product page, and the actor returned 22 offer rows in 33 seconds.

A few things stood out once the data was in a table:

Prices ran from 1,359 PLN to 2,999.90 PLN, with a median of 2,119 PLN.
Only one of the 22 offers was listed as new (Stan: Nowy), at 2,999.90 PLN. Ten were used, eight were ex-display ("Powystawowy"), two were seller-refurbished and one was marked as damaged.
The cheapest row (1,359 PLN) was the damaged unit. The cheapest used phone was 1,400 PLN.
21 of 22 offers had Allegro Smart!, and only one carried the Lowest Price Guarantee badge.
Two of the top three rows were promoted listings.

So the "lowest price" for this product, which the actor also reports as lowestPriceForProduct: 1359, is a damaged phone. If you compare your own new stock against that number, your repricing rule will do something silly. Grouping by condition fixes it, and the Python section shows how.

Fields you get

With outputFormat: "offers" you get one row per seller offer. The most useful columns:

Field	What it holds	Example from the run
`offerRank`	Position in the product's offer list	1
`title`	Offer title as the seller wrote it	Smartfon Apple iPhone 15 6 GB / 256 GB 5G czarny
`price`	Item price	2999.9
`priceWithDelivery`	Price plus cheapest delivery	3010.39
`deliveryFrom`	Cheapest delivery cost	10.49
`deliveryTime`	Delivery estimate shown on Allegro	dostawa jutro
`smart`	Allegro Smart! eligible	true
`lowestPriceGuarantee`	"Gwarancja najniższej ceny" badge	true
`promoted`	Sponsored placement	false
`superSeller`	Super Seller badge	true
`sellerRating`	Positive feedback percentage	95.7
`sellerIsCompany`	Business seller flag	true
`parameters`	Offer parameters such as condition and warranty	{"Stan": "Nowy", "Gwarancja": "12 miesięcy"}
`productRating`, `productReviewsCount`	Catalogue product rating	4.79, 106
`lowestPriceForProduct`	Lowest price on the product page	1359
`url`, `offerId`, `scrapedAt`	Offer link, ID and timestamp

There are also seller identifier fields (sellerLogin, sellerId, sellerUrl). In this run every seller was flagged as a company, but on a marketplace you can still hit private sellers, so the screenshots here leave those columns out and the Python example drops them before export.

With outputFormat: "products" you instead get one record per product with an offers[] array plus lowestPrice, highestPrice, avgPrice and offerCount. That suits dashboards. For analysis I prefer the flat version.

Input options

productUrls: product links (/produkt/...) or offer links (/oferta/...), one per line. If you paste an offer link, the actor finds the catalogue product behind it. Allegro.pl, .cz and .sk all work.
topNOffers: how many offers to return per product, 1 to 500, default 20.
sortBy: price-asc, price-desc or rating-desc.
smartFilter: all offers, Smart! only, or no Smart!.
includePromoted: switch off to drop sponsored offers.
detectHiddenDiscounts: for offers with the Lowest Price Guarantee badge, it reveals the price the seller actually set and the discount Allegro applies on top (realSellerPrice, hiddenDiscount). Charged per checked offer, so leave it off unless you need it.
onlyChanges and monitorId: monitoring mode. Each run returns only new offers and offers whose price moved since the last run, with previousPrice and priceChange. Unchanged offers are not charged.

Option 1: no code

Open the actor page and click Try for free.
In the Input tab paste your product links. The iPhone 15 link is prefilled if you just want to look.
Set "Top N offers per product" and pick "One row per offer" as output format.
Click Start. My single-product run took about half a minute.
Open the Output tab and export to Excel, CSV or JSON.

In Excel, add a filter on the parameters column and look at one condition at a time. That alone gives you a far more honest price spread than the product page does.

Option 2: Python with pandas

Install the client and pandas:

pip install apify-client pandas openpyxl

Then run the actor and summarise by condition:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "productUrls": [
        "https://allegro.pl/produkt/smartfon-apple-iphone-15-6-gb-256-gb-5g-czarny-b7d39356-8090-4bcf-9247-b872c5f6935a"
    ],
    "topNOffers": 25,
    "sortBy": "price-asc",
    "outputFormat": "offers",
}

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

# Condition lives inside the parameters dict ("Stan" on Allegro.pl)
df["condition"] = df["parameters"].apply(lambda p: (p or {}).get("Stan"))

summary = (
    df.groupby("condition")["price"]
      .agg(["count", "min", "median", "max"])
      .sort_values("median")
)
print(summary)

# Organic offers only, cheapest first, with delivery included
organic = df[~df["promoted"]].sort_values("priceWithDelivery")
print(organic[["offerRank", "price", "priceWithDelivery", "condition", "smart"]].head(10))

# Drop seller identifiers before you share the file
df.drop(columns=["sellerLogin", "sellerId", "sellerUrl"], errors="ignore") \
  .to_excel("iphone15_offers.xlsx", index=False)

On my run the summary came out like this:

condition	count	min	median	max
Uszkodzony (damaged)	1	1359.00	1359.00	1359.00
Używany (used)	10	1400.00	1949.00	2219.00
Powystawowy (ex-display)	8	1990.00	2154.00	2189.00
Odnowiony przez sprzedawcę (refurbished)	2	2156.98	2201.00	2245.02
Nowy (new)	1	2999.90	2999.90	2999.90

The gap between the median used phone and the one new offer was about 1,050 PLN. If you sell new units, the useful benchmark is the "Nowy" row, and with only one new offer in the top 25 you would raise topNOffers to see more of them.

Scheduling and integrations

For competitor tracking, turn on onlyChanges, give the watch list a monitorId such as competitors-iphone, and add a daily Schedule in Apify Console. Each run then returns only new offers and price changes. From there you can push results to Google Sheets, Slack, Make, Zapier or n8n, or pull them over the Apify API. The actor can also be called from AI agents through the Apify MCP server.

Pricing

The actor is pay per event. Current prices per 1,000 events:

Event	Free plan	Business plan
Seller offer scraped	$2.00	$1.50
Product compared	$8.00	$6.00

Starter and Scale plans fall in between. My run had 22 offer events, so at Free plan prices the offers cost about $0.044. Hidden discount detection is billed separately per checked offer.

Responsible use

The actor reads publicly visible listing data. Keep request volumes reasonable, respect Allegro's terms, and treat any seller identifiers as potential personal data under GDPR: drop or pseudonymise them unless you have a clear reason to store them. Use the output for price analysis, not for contacting individual sellers.

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

How to pull open EU public tenders from TED into Python and pandas

Norbert Sobala — Fri, 30 Oct 2026 08:27:22 +0000

Public tenders in Europe are published in one place: TED (Tenders Electronic Daily), the EU's official procurement journal. The data is open. The problem is volume and format. Notices arrive in 24 languages, values come in PLN, CZK or SEK, and the TED search UI is fine for browsing but slow if you want a daily shortlist in a spreadsheet.

This guide shows how I pull open tenders from TED into a table with the EU Tenders Scraper (TED) on Apify, first with no code, then with Python and pandas.

For the examples I ran one real search this morning: keyword cybersecurity, open tenders only, published in the last month, capped at 40 results. It returned 18 notices in 4.4 seconds. All numbers below come from that run.

What you get

Each row is one TED notice. The output has around 55 fields. These are the ones I use most:

Field	What it holds	Example from my run
`noticeId`	TED notice number	`755875-2026`
`title`	Title in the original language	Development, Implementation, Maintenance and Operation of financial IT Systems
`buyerName`, `buyerCountry`, `buyerCity`	Contracting authority	European Commission, DG BUDG, BE, Brussels
`cpvMain`, `cpvLabel`	Main CPV code and its label	`72000000`, IT services
`contractType`, `procedureType`	Services / supplies / works, open / restricted etc.	`services`, `open`
`estimatedValueEur`	Estimated value converted to EUR	700000000
`deadline`, `daysToDeadline`	Submission deadline and days left	2026-11-30, 32
`lotsCount`, `lots`	Number of lots with title and value per lot	2
`suitableForSme`, `euFunded`	Flags set by the buyer	`True`
`documentsUrl`, `submissionUrl`	Tender documents and e-submission links	ec.europa.eu links
`isCorrection`, `previousDeadline`, `deadlineChanged`	Correction tracking	`True`
`status`	open / closed / awarded	`open`

Award notices add winners (with country and company IDs), award value, number of bids and lowest/highest bid. I left awards out of this run to keep it short.

A few things from the 18 notices that are hard to see in the TED UI:

They came from 9 countries. Belgium had 7, Italy 3, Poland 2, and Finland, Albania, Czechia, Greece, Romania and France one each.
They were written in 8 languages. Five were in Dutch, so a keyword search in English alone still catches non-English notices here, but the README suggests adding the word in the buyer's language too.
11 of 18 had a published value. The median was €459,036. The largest was a €700M European Commission framework for financial IT systems, split into 2 lots.
Deadlines ranged from 1 to 47 days away, median 22. Three notices had a deadline that moved since the first version, and the actor flags that with deadlineChanged.
All 18 had both a documents link and an e-submission link.

Main input options

You don't need all 30-odd settings. These cover most searches:

keywords: full-text search in title, description and lots. keywordMode switches between any and all. excludeKeywords drops noise like window cleaning.
noticeStages: competition (open tenders), awards, or planning notices. Planning gives you a heads-up months before the tender.
countries and placeOfPerformance: buyer country, or a NUTS code like PL9 for Masovia.
cpvCodes: CPV prefixes. 72 is IT services, 45 construction, 33 medical equipment. This is language-independent, so it is more reliable than keywords for broad sectors.
minValue / maxValue: filter by estimated value. Notices without a value are excluded when you set these.
onlyOpen and deadlineWithinDays: only tenders you can still bid on, or only those closing within N days.
publishedWithin or publishedFrom / publishedTo: the date window.
includeBuyerHistory: for each tender, the buyer's past awards in the same sector, likely incumbent, top winners and average number of bids. This is charged separately.
aiEnrichment with companyProfile: translation into your language, a short summary, key requirements and a 0 to 100 fit score. Also charged separately.
onlyNew with monitorId: for scheduled runs, return only notices you haven't received before.
maxResults: the cap. I used 40.

Option 1: no code

Open the actor page and click Try for free. You need an Apify account; the free plan is enough for a test.
In Keywords, type your search. I used cybersecurity.
Under notice stages keep Tenders. Switch on Only open tenders.
Set Published within to a month and Max results to 40.
Click Start. My run finished in under 5 seconds.
Open the Output tab. Export to CSV, Excel or JSON, or send it straight to Google Sheets.

If the table is too wide, the export dialog lets you pick columns. I usually keep title, buyer, country, value, deadline and the two links.

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:

import os
import pandas as pd
from apify_client import ApifyClient

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

run_input = {
    "keywords": ["cybersecurity"],
    "noticeStages": ["competition"],
    "publishedWithin": "month",
    "onlyOpen": True,
    "maxResults": 40,
}

run = client.actor("flarewow/eu-tenders-ted-scraper").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items(clean=True).items
df = pd.DataFrame(items)

cols = ["noticeId", "buyerName", "buyerCountry", "cpvLabel",
        "estimatedValueEur", "daysToDeadline", "url"]
shortlist = (
    df[cols]
    .sort_values("daysToDeadline")
    .reset_index(drop=True)
)
print(shortlist.head(10).to_string())

print(df["buyerCountry"].value_counts())
print("Median value (EUR):", df["estimatedValueEur"].median())

shortlist.to_csv("ted_cyber_open.csv", index=False)

Keep the token in an environment variable, not in the script. On my 18 rows value_counts() printed BE 7, IT 3, PL 2 and six countries with 1, and the median came out at 459036.0. pandas skips the 7 empty values when it computes the median.

One small thing: estimatedValueEur is already converted with ECB reference rates, so you can sort Polish and Czech notices next to euro ones without doing the maths yourself. Use currency and estimatedValue if you need the original figure.

If you bid on single lots, set "splitLots": True. Each lot becomes its own row with its own value. Each row then counts as one notice for billing.

Scheduling and integrations

For a daily alert, set onlyNew to true and give the search a monitorId such as cyber-eu. Then create a schedule in Apify Console (Schedules, daily at 7:00, for example). Each run returns only notices that weren't delivered before, and you aren't charged twice for the same one.

From there you can push results to Google Sheets, Slack, Make, Zapier, n8n or any webhook. I send the CSV to a sheet and let a filter view do the rest.

Pricing

The actor uses pay-per-event pricing. At the time of writing:

Event	Free plan	Business
Notice	$6.00 per 1,000	$4.50 per 1,000
Buyer intelligence	$0.020 per tender	$0.015 per tender
AI analysis	$0.030 per notice	$0.020 per notice

My 18 notices came to $0.108 at the free-plan rate. Tender to award linking and EUR conversion are free. Check the actor page for current prices before a big job.

Responsible use

TED is official EU open data, published for re-use, and the actor reads it through the official TED API. That said, notices can contain the name, email or phone of a contact person at the buyer. Treat those as personal data under GDPR. Use them to respond to the tender, don't build marketing lists from them, and leave them out of anything you publish. In the screenshot above I left the contact fields out.

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 OLX.pl apartment listings with price per m into Python and pandas

Norbert Sobala — Wed, 28 Oct 2026 08:25:15 +0000

Polish property portals don't offer a public export button, and OLX.pl is one of the biggest sources of apartment listings in the country. If you want asking prices per square metre for a district, or a daily feed of fresh listings for an agency CRM, you need the data in a table first.

This guide uses the OLX Real Estate Scraper on Apify. I ran it while writing this post with a small search: 2-room apartments for sale in Kraków, capped at 50 listings. The run finished in 5.5 seconds. Every number below comes from that dataset.

What you get per listing

One listing becomes one row. These are the fields I got back:

Field	Example from the run	Notes
`title`	2-room flat ad title	As written by the advertiser
`price`, `currency`	607034, PLN	Asking price
`pricePerM2`	16147.0	Calculated by the scraper from price and area
`areaM2`	40.0	Floor area
`rooms`	"2 pokoje"	Polish label from OLX
`floor`	"5"	Can be null
`market`	Pierwotny / Wtórny	Primary (developer) or secondary market
`buildingType`	Blok, Apartamentowiec, Kamienica	Block, apartment building, tenement
`furnished`	Tak / Nie	Yes / No
`isBusiness`	true	Agency or developer vs private owner
`sellerName`	(empty in my run)	Treat as personal data, see below
`city`, `district`, `region`	Kraków, Podgórze, Małopolskie	District was missing on 3 of 50 rows
`lat`, `lon`	50.09, 19.93	Map coordinates
`createdTime`	ISO timestamp	When the ad was posted
`photos`, `description`, `url`		Description comes as HTML

In monitoring mode two extra fields appear: changeType (new listing or price change) and previousPrice.

What the 50 Kraków listings looked like

It's a small sample from one morning, so don't read too much into it.

Median asking price: 607,034 PLN. Cheapest 420,000, most expensive 1,210,023.
Median price per m²: 16,147 PLN. The range was wide, from 11,598 to 27,900.
Area: 30 to 69 m², median 40.
22 listings were primary market and 28 secondary. Primary flats had a median of 16,650 PLN/m², secondary ones 15,040.
43 of 50 ads came from businesses. Only 7 were private owners.
Podgórze had the most listings (9), then Prądnik Biały (7).

That 43 to 7 split is something you only notice once the data is in a dataframe. If you build lead lists for an agency, the ownerType filter matters a lot.

The main input options

The input form is in Polish, because the actor was built for Polish agencies. The values you will touch most:

subcategory: mieszkania (apartments), domy (houses), dzialki (plots), biura-lokale (offices and retail), garaze-parkingi (garages), stancje-pokoje (rooms).
transaction: sprzedaz (sale), wynajem (rent) or zamiana (swap).
city plus radiusKm (0, 5, 10, 15, 30, 50, 75 or 100). City Kraków with 30 km picks up the surrounding towns too, which helps for houses and plots.
district: optional, narrows to one district.
priceMin, priceMax, areaMin, areaMax and for plots plotAreaMin, plotAreaMax.
rooms: list with one, two, three, four (four means 4 or more).
buildingType, floor, market (primary / secondary), furniture.
ownerType: private or business.
postedWithin: 24h, 7d, 30d or all.
maxItems: a cost cap per run. Default is 500.
searchUrls: paste search links copied from OLX.pl. They override every filter above.

Option 1: no code

Open the actor page and click Try for free. You need a free Apify account.
Pick the category and transaction type. I used apartments for sale.
Type the city and choose room count. Set Max items to something small for the first try, I used 50.
Click Start. My run took a few seconds.
Open the Output tab and export to CSV, Excel or JSON.

If you already have a search open on OLX with all the filters you like, copy its URL into the advanced searchUrls field. Faster than rebuilding it field by field.

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 = {
    "subcategory": "mieszkania",
    "transaction": "sprzedaz",
    "city": "Kraków",
    "rooms": ["two"],
    "maxItems": 50,
}

run = client.actor("flarewow/olx-nieruchomosci-pl").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items

df = pd.DataFrame(items)
df = df.drop(columns=["sellerName", "description", "photos"], errors="ignore")

print(len(df), "listings")
print("median price/m2:", df["pricePerM2"].median())
print(df.groupby("market")["pricePerM2"].median().round(0))
print(df["district"].value_counts().head(5))

df.to_csv("krakow_2_rooms.csv", index=False)

On my dataset this printed 50 listings, a median of 16,147 PLN/m² and the primary vs secondary split shown earlier. I drop sellerName right after loading because I don't need it for price analysis and I'd rather not store it.

A quick per-district view is one line more:

(df.dropna(subset=["district"])
   .groupby("district")
   .agg(listings=("id", "count"), median_m2=("pricePerM2", "median"))
   .sort_values("listings", ascending=False))

With 50 rows most districts have 2 to 4 listings, so raise maxItems before you draw conclusions per district.

Scheduling and monitoring new listings

The part agencies use most is monitoring. Set monitorNew to true and the actor remembers which listings it has already seen for that search. The first run builds the baseline. After that, each run returns only listings that are new since the last one. With detectPriceChanges on (the default) it also flags price drops and rises on listings it already knows, with the old price in previousPrice.

To make that useful, add a schedule in the Apify Console (Schedules tab): hourly for a busy city, daily for a small town. From there the results can go to Google Sheets, Slack, Make, Zapier, n8n or a webhook. The actor also works through the Apify MCP server, so you can call it from Claude, ChatGPT or Cursor.

Pricing

The actor is pay per event. Current prices per 1,000 scraped listings:

Apify plan	Per 1,000 listings	Per 1,000 new listings (monitoring)
Free	$8	$15
Bronze	$6	$12
Silver	$5	$10
Gold and above	$4	$8

Price changes in monitoring mode cost the same as a scraped listing. There is also a $0.05 charge per run start, and the first 100 listings are free for a new user. So a 50-listing test like mine fits inside the free allowance.

Responsible use

The scraper reads public listing data through the same JSON API the OLX app uses. Some ads come from private owners, and fields like sellerName or the free-text description can contain personal data. Under GDPR (RODO in Poland) you need a legal basis to store and process that. For price research, drop those columns right away, as in the code above. For lead generation, the ownerType: business filter keeps you to agencies and developers. Keep maxItems reasonable and don't hammer the site with schedules every few minutes.

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

How to track Allegro prices from every seller by EAN barcode with Python

Norbert Sobala — Mon, 26 Oct 2026 08:30:45 +0000

If you sell on Allegro or buy stock for resale in Poland, the question you ask every week is simple: who else sells this exact product, and at what price? Searching by product name gets messy fast. Searching by EAN barcode is cleaner, because one barcode should point to one product card on Allegro, and that card lists every seller.

This tutorial shows how to pull that seller list for a batch of EAN codes with the Allegro EAN Price Tracker on Apify. First without code, then from Python with pandas. Every number below comes from one test run I did on 4 barcodes.

What the test run returned

Input: 4 EAN codes, Allegro.pl, up to 10 offers per product, cheapest first, one row per offer.

The run took 241 seconds and returned 24 rows: 23 seller offers plus 1 row for a barcode Allegro did not know.

EAN	Product on Allegro	Offers	Lowest	Highest	Average
195949036842	Apple iPhone 15 6 GB / 256 GB 5G, black	10	1,400.00 PLN	3,173.90 PLN	2,040.49 PLN
5702017584072	LEGO Technic 42173 Koenigsegg Jesko Absolut	3	175.67 PLN	419.90 PLN	265.19 PLN
5449000000996	5 l PET bottle listing	10	4.00 PLN	4.00 PLN	4.00 PLN
5900084231472	not found	0

A few things stood out. The iPhone spread is huge, more than 1,700 PLN between the cheapest and the most expensive offer for the same product card. Of those 10 iPhone offers, 9 had Allegro Smart! delivery, 6 came from Super Sellers and 3 were promoted placements. The most expensive one carried the Lowest Price Guarantee badge and a 12-day delivery time.

The third barcode is a good warning. I used the example code from the actor's input description and it matched a listing for a 5-litre PET bottle. Always read productName before you trust a row.

What data you get

With outputFormat: "offers" you get one flat row per seller offer. These are the fields I found most useful:

Field	What it holds
`ean`	The barcode you sent
`productName`	Name of the Allegro product card the EAN matched
`title`	The seller's own offer title
`price` / `priceWithDelivery`	Item price and price including the cheapest delivery, in PLN
`deliveryTime`	Delivery text as Allegro shows it, e.g. "dostawa jutro"
`smart`	Offer has Allegro Smart! delivery
`superSeller` / `sellerRating`	Super Seller badge and positive rating in percent
`sellerIsCompany`	Whether the seller account is a business
`promoted`	Sponsored placement
`lowestPriceGuarantee`	Offer has the "Gwarancja najniższej ceny" badge
`productRating` / `productReviewsCount`	Product card rating and review count
`url`	Link to the offer

Barcodes that match nothing come back as a row with found: false and a note. In my run that note read "No Allegro product with this EAN (Allegro only showed similar products)."

With outputFormat: "products" (the default) you get one record per EAN instead, with lowestPrice, highestPrice, avgPrice, offerCount and the offers nested in an offers[] array. Use that when you only care about the price range per product.

Option 1: no code

Open the actor page and click Try for free.
Paste your barcodes into EAN / GTIN codes, one per line.
Pick the marketplace. Allegro.pl is the default, Allegro.cz and Allegro.sk are also supported.
Set Top N offers per product. The default is 20, the maximum is 500.
Choose the output format and click Start.
When the run finishes, export the dataset as Excel, CSV or JSON.

The main input options:

topNOffers: how many seller offers per product.
sortBy: price-asc, price-desc or rating-desc. In my run the dataset rows did not come out in price order, so sort again on your side.
smartFilter: all, smart-only or exclude-smart.
includePromoted: set to false to drop sponsored offers.
detectHiddenDiscounts: for offers with the Lowest Price Guarantee badge, it adds the price the seller actually set (realSellerPrice) and how much Allegro covers. This one is billed per checked offer, so leave it off unless you need it.
onlyChanges with monitorId: monitoring mode, explained below.

Option 2: Python with apify-client and pandas

Install the two libraries:

pip install apify-client pandas

Then run the actor and load the results into a DataFrame. You need your Apify API token from the Integrations page in the Apify Console. Keep it in an environment variable, not in the script.

import os
import pandas as pd
from apify_client import ApifyClient

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

run_input = {
    "eans": ["195949036842", "5702017584072", "5449000000996", "5900084231472"],
    "marketplace": "pl",
    "topNOffers": 10,
    "sortBy": "price-asc",
    "smartFilter": "all",
    "includePromoted": True,
    "outputFormat": "offers",
}

run = client.actor("liveclaude/allegro-ean-price-tracker").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items(clean=True).items
df = pd.DataFrame(items)

# Barcodes Allegro did not recognise
if "found" in df.columns:
    missing = df[df["found"] == False]
    print("Not found:", missing["ean"].tolist())

offers = df[df["price"].notna()].copy()

summary = (
    offers.groupby(["ean", "productName"])
    .agg(
        offers=("price", "size"),
        lowest=("price", "min"),
        highest=("price", "max"),
        median=("price", "median"),
        smart_share=("smart", "mean"),
    )
    .round(2)
    .sort_values("offers", ascending=False)
)
print(summary)
summary.to_csv("allegro_ean_prices.csv")

One cleanup step is worth adding. On the iPhone card, some offer titles mentioned ex-display units ("Powystawowy"), condition notes ("Stan: bardzo dobry") or even a different variant (one said 15 Plus, another 128GB). Sellers attach offers to product cards loosely, so filter titles before you compare prices:

noise = r"powystaw|stan:|używan|kondycja|plus|128gb"
clean = offers[~offers["title"].str.contains(noise, case=False, na=False)]
cheapest = clean.sort_values("priceWithDelivery").groupby("ean").head(3)
print(cheapest[["ean", "price", "priceWithDelivery", "smart", "superSeller", "url"]])

Adjust the pattern for your product category. For LEGO sets you will want different words than for phones.

Scheduling and price alerts

For ongoing tracking, turn on onlyChanges and give the watch list a monitorId, for example competitors-lego. Then add a schedule in Apify, say every morning at 7:00. Each run returns only new sellers and offers whose price changed since the previous run, with previousPrice, priceChange and priceChangePercent. According to the actor's README, unchanged offers are not charged.

From there you can push results to Google Sheets, Slack, email, Make, Zapier or n8n through Apify integrations, or poll the dataset from your own repricing script. Use a separate monitorId per list so the change history stays clean.

Pricing per 1,000 results

The actor uses pay per event. Current prices on the Free plan, with the Business plan price in brackets:

Product resolved by EAN: $10 per 1,000 EANs ($7 on Business)
Seller offer: $2 per 1,000 offers ($1.50 on Business)
EAN not found: $1 per 1,000
Hidden discount check: $10 per 1,000 checked offers, only if you enable it

So 1,000 barcodes with 10 offers each would come to roughly $10 for products plus $20 for 10,000 offers on the Free plan, before the small per-run start fee. Matched products are cached for 24 hours, which helps if you rerun the same list the same day.

Responsible use

The actor reads publicly visible offer data. In my run all 23 offers came from business accounts, but Allegro also has private sellers, and a seller login can be a person's nickname. If you store or share results, drop or mask sellerLogin and sellerUrl unless you have a reason and a legal basis to keep them, and handle any personal data under GDPR. Keep run frequency sensible: once or twice a day is plenty for price monitoring.

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 Kleinanzeigen.de listings by city and radius with Python

Norbert Sobala — Thu, 22 Oct 2026 07:31:09 +0000

Kleinanzeigen.de, formerly eBay Kleinanzeigen, is Germany's biggest classifieds site. People sell bikes, cars, furniture and flats there. The site itself only shows 25 listings per page and stops after 50 pages. For a price check or a daily alert you want the data in a table. This post walks through the Kleinanzeigen Scraper on Apify, first without code and then from Python.

My test search: e-bike within 20 km of Berlin, newest first, capped at 40 listings. Every number below is from that run on 22 October 2026.

What the run returned

Kleinanzeigen reported 2,208 matching listings for that search. I only took the newest 40, which covered roughly 12 and a half hours of posts (the oldest timestamped one was from 18:54 UTC the evening before, the newest from 07:20 UTC). Expect a busy category in a big city to fill up fast.

The price summary row gave me this for the 33 listings it analysed:

Metric	Value
Min	2 EUR
25th percentile	850 EUR
Median	1,899 EUR
Average	2,002.55 EUR
75th percentile	2,499 EUR
Max	6,599 EUR
Negotiable (VB)	12.12%
Price reduced	3.03%
Shipping offered	72.73%

The top location was Lichtenberg with 16 listings, far ahead of every other district. Most of those came from shops, which brings me to the first lesson: 24 of the 40 listings were from PRO (commercial) sellers, and 4 were promoted TOP ads.

The 2 EUR minimum was a luggage strap, which matched "e-bike" somewhere in its text. More on filtering that out below.

Fields you get per listing

Field	Example from this run	Notes
`title`	Giant Explore E+ 2 STA amber glow XL E-Bike
`price`, `priceType`	1999, fixed	`negotiable` for VB listings
`originalPrice`, `priceReduced`		Filled when the seller cut the price
`location`, `postalCode`	Friedrichshain, 10243
`distanceKm`	4	Distance from your search location
`postedAt`	2026-10-22T06:08:00Z	Missing on some TOP ads
`shippingAvailable`, `buyNow`	true	"Versand möglich", "Direkt kaufen"
`isTopAd`	false	Promoted listing
`sellerType`, `isProSeller`, `shopName`	commercial, true, Radwelt Mitte RWM 1 GmbH	Shop name only for PRO sellers
`mileageKm`, `firstRegistration`		Cars, already in search results
`livingSpaceM2`, `rooms`		Real estate
`imageUrl`, `imageCount`, `url`

With Listing details on, you also get the full description, all attributes (brand, model, frame size and so on), the equipment list, all photos and GPS coordinates.

Option 1: no code

Open the Kleinanzeigen Scraper and click Try for free. A free Apify account is enough. You do not need a Kleinanzeigen login or your own proxies.
Type e-bike into Search terms.
Set Location to Berlin and Radius to 20 km. Postcodes like 80331 work too.
Set Max. listings per search to 40.
Add suche and defekt to Exclude words. That drops "looking for" posts and broken bikes, and filtered listings are free.
Turn on Price summary per search.
Click Start. Then open the Listings or Price summaries view, or export CSV, Excel or JSON.

Input options worth knowing

Kleinanzeigen URLs: set filters on kleinanzeigen.de in your browser and paste the link. Category-specific filters (mileage, first registration, rooms, living space, brand) stay in the URL and the scraper keeps them. Single listings, seller pages and PRO shops work as well.
Categories: limit keywords to one or more categories. Picking the e-bike category would have kept my luggage strap out.
Title must include (any): keep only listings whose title has one of your words. Also a fix for the strap.
Min. / Max. price: a 100 EUR floor removes most accessories in one go.
Listing type: offers, wanted ads, or both.
Seller type: private or commercial. Useful here, since shops dominated the results.
Shipping and Only "Direkt kaufen": shipping only, pickup only, or buy-now listings.
Posted within (hours): for example 24. The search stops once it reaches older listings, so daily runs stay cheap.
Only price-reduced listings: listings where the seller crossed out an older price.
Include TOP ads: switch off for organic results only.
Get more than 1,250 results: on by default. Big searches are split into price ranges to get past the 50 page limit.
Sellers to track: user IDs, seller links or PRO shop names, with their profile and active listings.

Option 2: Python with apify-client and pandas

pip install apify-client pandas

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchQueries": ["e-bike"],
    "location": "Berlin",
    "radiusKm": "20",
    "maxItemsPerSearch": 40,
    "excludeKeywords": ["suche", "defekt"],
    "priceSummary": True,
}

run = client.actor("liveclaude/kleinanzeigen-scraper").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items

df = pd.DataFrame(items)
listings = df[df["recordType"] == "listing"].copy()
summary = df[df["recordType"] == "price-summary"]

# shops carry sellerType "commercial"; other listings have no shop attached
listings["seller"] = listings["sellerType"].fillna("no shop")

bikes = listings[listings["price"] >= 100]
print(bikes.groupby("seller")["price"].agg(["count", "median", "min", "max"]))

bikes.to_csv("ebikes_berlin.csv", index=False)

Note that radiusKm is a string. The input form offers fixed values (0, 1, 2, 3, 5, 10, 15, 20, 30, 50, 100, 150, 200).

Output from my run:

            count  median     min     max
seller
commercial     23  2499.0  1590.0  6599.0
no shop        12   815.0   249.0  2000.0

That split tells you more than the overall median. Shops in this search started at 1,590 EUR and sat around 2,499 EUR. Listings without a shop had a median of 815 EUR. If you are hunting for a used e-bike, set Seller type to private and the overall 1,899 EUR median stops being misleading.

Two listings were below 100 EUR and the filter dropped them.

Scheduling and alerts

The scraper has a monitoring mode built for alerts:

Save your input as a task.
Turn on Only new listings (monitoring). Later runs return only listings you have not seen, plus price drops.
Keep Detect sold / reserved / deleted listings on. Listings that vanish are reported as sold, reserved or removed, with daysOnMarket. Every record has listingStatus so you can route them.
Combine with Posted within (hours) set to 2 or 24 and schedule hourly or daily.
Give the task a Monitor name like ebikes-berlin if you run several monitors.

For searches over 2,000 results, sold detection and older price drops only work after you narrow the search with a location, category or price range. My 2,208 result query would need a price band for that.

Results can go to Google Sheets, Slack, Make, Zapier, n8n or any webhook, or you can call the scraper from an AI agent through the Apify MCP server.

Pricing per 1,000 results

Pay per event. Current prices per 1,000 events:

Event	Free	Starter	Scale	Business
Listing	$1.30	$1.20	$1.05	$0.90
Listing details (optional)	$1.20	$1.10	$1.00	$0.90
Seller / shop profile	$2.00	$1.80	$1.60	$1.50

A price summary row costs about one cent and each run has a start fee of $0.00005. Filtered listings, already seen listings in monitoring mode and failed pages are free. At Free plan prices, my 40 listing run with one summary works out to roughly six cents. You can set a maximum cost per run and it stops there.

Responsible use

Many Kleinanzeigen sellers are private people. The scraper does not collect phone numbers or e-mail addresses of private sellers, and Kleinanzeigen hides them anyway. PRO shops publish business contact details on their shop pages, and only those end up in seller records. If you turn on seller profiles, you may get display names of private sellers too; leave them out of anything you publish or share, and keep in mind that GDPR covers storing them. Kleinanzeigen's terms apply to what you do with the data. Use small, targeted searches with filters and you will collect less data and pay less.

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

How to compare eBay prices across countries with Python (UK vs Germany example)

Norbert Sobala — Thu, 22 Oct 2026 07:30:18 +0000

Is a used Steam Deck OLED cheaper on ebay.de or on ebay.co.uk? I wanted a quick answer with real listings instead of scrolling two sites and converting currencies in my head. This post shows how I got it with the eBay Scraper on Apify: first with no code, then with a short Python script that loads everything into pandas.

All numbers below come from one run on 22 October 2026: the query steam deck oled on two sites, capped at 20 listings per site.

What the run returned

The run saved 24 listings: 18 from ebay.de and 6 from ebay.co.uk. The UK search came back thinner than the German one, so treat the UK side as a small sample. On top of the listings, the scraper added two price summary rows (one per site) and one site comparison row.

The summary rows did the currency work for me:

Site	Listings	Min	Median	Max	Median in USD
ebay.de	18	441 EUR	640 EUR	919.95 EUR	718.98
ebay.co.uk	6	419.99 GBP	550 GBP	618.70 GBP	737.09

The comparison row marked de as the cheaper site, with a median spread of 18.11 USD. That gap is small. Condition matters more than the country here, as the pandas section shows.

Fields you get per listing

These are the columns I used most. Every listing record has them, though some are empty when eBay does not show the value.

Field	Example from this run	Notes
`title`	Valve Steam Deck OLED 512 GB Handheld Spielkonsole	As shown on eBay
`price`, `currency`	450, EUR	Local currency of the site
`priceUsd`	505.53	Converted, handy for cross-site work
`shippingCost`, `totalPrice`	7.69	Total is price plus shipping
`condition`	Gebraucht	In the site's language
`buyingFormat`	auction / buy-it-now
`bids`	21	Auctions only
`watchers`, `soldCount`	17, 591	Only when eBay displays them
`sellerType`	private / business	Shown on sites like ebay.de
`sellerFeedbackPercent`, `sellerFeedbackCount`	100, 1090	Seller reputation
`marketplace`, `site`	ebay.de, de	Which eBay site it came from
`epid`, `imageUrl`, `url`		Product ID, photo, link

Every record also has recordType: item for a listing, price-summary for the per-site stats, site-comparison for the cross-site row. That one field makes filtering easy later.

Option 1: no code

Open the eBay Scraper page and click Try for free. You need a free Apify account. No eBay account is involved.
In Search queries, type steam deck oled.
In eBay sites, pick United Kingdom and Germany. There are 15 sites in total, and a switch to search all of them at once.
Set Max listings per search to 20 while you test.
Add case, skin and hülle to Exclude words in title. Accessory listings drop out and you are not charged for them.
Leave Price summary per search on and turn on Compare prices between eBay sites.
Click Start. My run finished in under a minute.
Open the Price summaries view for the numbers above, or export everything as CSV, Excel or JSON.

Input options worth knowing

eBay URLs: set filters on eBay in your browser and paste the link. Search pages, categories (/b/...), stores, seller pages and single listings (/itm/...) all work.
Filters in the form: category ID, min and max price, condition (new, open box, refurbished, used, for parts), auction or Buy It Now, Best Offer only, free shipping only, item location, seller type, minimum seller feedback, sort order.
Title must contain: the opposite of exclude words. One UK result was titled "Valve Steam Deck 512GB Handheld Console - Black" with no "OLED" in it. Adding oled here would have removed it.
Listing details: opens each listing and adds item specifics, brand, MPN, EAN/UPC, all photos and returns info. Costs extra, so only switch it on when you need those fields.
EAN / UPC codes: search by barcode instead of keywords.
Sellers: give usernames to get a profile, active listings and recent buyer feedback with prices paid.
Only new listings: monitoring mode, covered below.
Go past eBay's 10,000 result limit: big searches get split into price ranges automatically.

Option 2: Python with apify-client and pandas

Install the two packages:

pip install apify-client pandas

Then run this. Put your own API token from the Apify console in place of the placeholder.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchQueries": ["steam deck oled"],
    "sites": ["uk", "de"],
    "maxItemsPerSearch": 20,
    "excludeKeywords": ["case", "skin", "hülle"],
    "priceSummary": True,
    "compareSites": True,
}

run = client.actor("liveclaude/ebay-scraper").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items

df = pd.DataFrame(items)
listings = df[df["recordType"] == "item"].copy()
summaries = df[df["recordType"] == "price-summary"]

by_condition = listings.groupby(["marketplace", "condition"])["price"].agg(["count", "median"])
print(by_condition)

print(listings.groupby("marketplace")["totalPrice"].median())

# keep seller usernames out of files you share
listings.drop(columns=["sellerName"], errors="ignore").to_csv("steam_deck_ebay.csv", index=False)

The first print gave me this:

                             count   median
marketplace condition
ebay.co.uk  Pre-owned            6  549.995
ebay.de     Gebraucht           11  599.900
            Neu                  4  734.475
            Neu (Sonstige)       3  630.000

So ebay.de had a mix of 11 used and 7 new or "new other" units, while all 6 UK listings were pre-owned. The German overall median of 640 EUR is pulled up by those new units at a median of 734.48 EUR. If you only care about used devices, the fair comparison is 599.90 EUR against 550 GBP.

Shipping changes the picture a bit too. Median totalPrice was 650.69 EUR on ebay.de and 562.47 GBP on ebay.co.uk. Two UK sellers charged 20 GBP for delivery, which is a lot on a 550 GBP item.

Auctions are worth a separate look. Germany had 4 of them. Two had bids (15 bids at 441 EUR, 21 bids at 505 EUR) and two had none yet. Those prices will move until the auction ends, so do not mix them into a "typical price" without checking timeLeft.

Scheduling and integrations

A one-off run answers one question. For price tracking, schedule it.

Save your input as a task in the Apify console.
Turn on Only new listings (monitoring). Each run then returns only listings it has not seen, plus price drops.
Leave Track final prices of ended listings on. When a tracked listing ends, the scraper opens its public page and records the final price, bids, end date and whether it sold. Each record carries listingStatusChange with new, price-drop, sold, ended-unsold or removed.
Add a schedule, for example daily at 07:00.

This matters because since July 2026 eBay shows sold and completed searches only to signed-in users. The scraper does not log in, so monitoring is how you collect real sale prices over time.

For delivery, connect the dataset to Google Sheets, Make, Zapier, n8n or a webhook. You can also call liveclaude/ebay-scraper from an AI agent through the Apify MCP server.

Pricing per 1,000 results

The scraper uses pay per event pricing. Current prices per 1,000 events:

Event	Free	Starter	Scale	Business
Listing	$3.20	$2.90	$2.70	$2.50
Listing details (optional)	$5.00	$4.50	$4.20	$4.00
Description (optional)	$5.00	$4.50	$4.20	$4.00
Seller profile	$5.00	$4.50	$4.20	$4.00
Buyer feedback entry	$2.50	$2.20	$2.00	$1.80

A price summary or site comparison row costs about one cent each. Listings removed by your filters, already seen listings in monitoring mode and failed pages are free. My test run cost well under 10 cents. You can set a maximum cost per run in the run options and the scraper stops there.

Responsible use

The scraper collects publicly visible listing data and does not use an eBay account or cookies. Search results can include seller usernames, and on eBay many sellers are private people. I drop sellerName before saving or sharing anything, as in the script above, and work with feedback counts and seller type instead. If you store data on individuals, GDPR applies to you, and eBay's terms apply to how you use the data. Keep request volumes sensible and only collect what you need for the question you are answering.

For my question the answer was short: used units sat around 600 EUR in Germany and 550 GBP in the UK. At that gap, shipping and condition decide which listing is the better deal.

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 Vinted listings and compare prices across countries with Python

Norbert Sobala — Wed, 21 Oct 2026 07:25:22 +0000

Vinted runs 26 separate marketplaces, and the same jacket can show up on vinted.de, vinted.fr and vinted.it at once. If you resell, track second-hand prices or build a deal alert, you want that data in a table instead of 40 open browser tabs.

This guide uses the Vinted Scraper on Apify. I ran it this morning with a small test: the query levis 501, 25 newest listings each from Germany and France, plus the country price comparison switched on. It finished in about 15 seconds and returned 50 listings and one comparison row. Every number below comes from that run.

What data you get

Each listing is one row. These are the fields I used most in the test run:

Field	Example from the run	Notes
`title`	Jean Levi's 501	as written by the seller
`price`	35	item price in local currency
`buyerProtectionFee`	2.45	Vinted's buyer fee
`totalPrice`	37.45	what a buyer actually pays before shipping
`priceEur`, `totalPriceEur`	35, 37.45	converted to EUR for cross-country work
`brand`, `size`, `condition`	Levi's, EU 38, Très bon état	condition comes in the marketplace language
`favouriteCount`	1	a rough demand signal
`sellerIsBusiness`	false	private seller vs Vinted Pro
`country`, `marketplace`	fr, vinted.fr	where the listing was found
`photoUrls`	list of image URLs
`url`, `id`	link to the listing
`recordType`	item	`country-comparison` for summary rows

Turn on Listing details and you also get the full description, all photos, category path, colour, material, shipping price and sold/reserved status. Seller profiles adds seller country, rating, review count, items sold and followers. Both cost extra per record, so leave them off until you need them.

The comparison row is a separate record. For my query it held min, 25th percentile, median, average, 75th percentile and max price per country, the cheapest country and the link to the cheapest listing.

What the test run showed

A few things stood out in the 50 rows:

Median total price (item plus buyer fee) was 26.95 EUR on both sites. The cheapest listing cost 8.05 EUR on both.
19 of the 25 listing IDs from vinted.de were also in the vinted.fr results. Vinted shows cross-border listings on EU sites, so "the German market" and "the French market" overlap a lot.
44 listings came from private sellers and 6 from business accounts.
41 of 50 had zero favourites. These were the newest listings, so that is expected.
42 titles contained "501". The other 8 were other Levi's models (504, unlabeled jeans), because Vinted search is fuzzy.

The overlap is the practical lesson. If you want to compare real local prices, use the Seller countries filter or turn on seller profiles, so the comparison is grouped by where the seller is located instead of which domain the listing appeared on. The README says the same, and my run confirmed it.

Option 1: no code

Open the Vinted Scraper page and click Try for free. You need a free Apify account.
The easiest input is a URL. Set your filters on any Vinted site in the browser (brand, size, price, condition), copy the address bar and paste it into Vinted URLs. Category, brand, single listing and seller wardrobe links work too.
Or type keywords into Search queries, one per line, and pick the Countries. Each query runs in every selected country.
Set Max listings per search. I used 25. 0 means everything, and the actor splits the search into price ranges to get past Vinted's 960-result cap.
Optional: tick Compare prices between countries if you picked two or more countries.
Click Start, then export the dataset as CSV, Excel or JSON.

Main input options

Search queries and Vinted URLs: what to scrape. You can mix both.
Countries or All 26 countries: which marketplaces to search.
Sort by: newest_first (default), relevance, price_low_to_high, price_high_to_low.
Categories, Brands, Sizes, Condition, Colours, Material IDs, Min/Max price: the same filters as on the website. Names or IDs both work; sizes behave best together with a category.
Exclude words in title and Title must contain: cleans up fuzzy search. Excluded listings are free. In my run, titleMustInclude: ["501"] would have dropped the 8 off-model rows.
Seller type, Seller countries, Min favourites: filter by private vs business, seller location and demand.
Listing details and Seller profiles: paid enrichment, described above.
Only new listings, Also return price drops, Also detect sold / removed listings, Monitor name: monitoring mode, covered below.

Option 2: Python with apify-client and pandas

Install the two packages:

pip install apify-client pandas

Put your Apify API token in an environment variable called APIFY_TOKEN (Console, Settings, API & Integrations). Then:

import os
from apify_client import ApifyClient
import pandas as pd

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

run_input = {
    "searchQueries": ["levis 501"],
    "countries": ["de", "fr"],
    "maxItemsPerSearch": 25,
    "sortBy": "newest_first",
    "compareCountries": True,
}

run = client.actor("liveclaude/vinted-scraper").call(run_input=run_input)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())

listings = pd.DataFrame([i for i in items if i.get("recordType") == "item"])
comparison = [i for i in items if i.get("recordType") == "country-comparison"]

# price summary per marketplace
print(
    listings.groupby("marketplace")["totalPriceEur"]
    .describe()[["count", "min", "50%", "max"]]
)

# how many listings appear on both sites
de_ids = set(listings.loc[listings["country"] == "de", "id"])
fr_ids = set(listings.loc[listings["country"] == "fr", "id"])
print("Shared listings:", len(de_ids & fr_ids))

# ten cheapest listings
cols = ["marketplace", "title", "size", "condition", "totalPriceEur", "url"]
print(listings.sort_values("totalPriceEur")[cols].head(10))

for row in comparison:
    for c in row["countries"]:
        print(c["marketplace"], "median", c["medianPriceEur"], "EUR")

listings.to_csv("vinted_levis_501.csv", index=False)

With my input this printed a median of 26.95 EUR for both marketplaces and 19 shared listings. Your numbers will differ because Vinted listings change every minute.

Two small notes. The condition column is localized ("Sehr gut" on vinted.de, "Très bon état" on vinted.fr), so map it to one language before you group by it. And filter on recordType as shown, because the comparison row has a different shape from the listing rows.

Scheduling, monitoring and integrations

The part I would use day to day is monitoring. Switch on Only new listings, give the run a Monitor name, and create a schedule in Apify Console (every 15 minutes or every hour). Each run then returns only listings it has not seen before. Every record gets a listingStatus of new, price-drop, sold or removed. Price drops include the previous price and the drop percentage. Sold and removed items include first seen date, last seen date and days on market, which is useful sell-through data if you resell.

Already seen listings are not charged, so a monitor that finds 5 new items costs a fraction of a cent.

From there you can push results to Google Sheets, Slack, Make, Zapier, n8n or a webhook through the Integrations tab. The actor can also be called from AI agents through the Apify MCP server.

Pricing per 1,000 results

Pay per event, proxies included. Current prices from the actor page:

Event	Free plan	Starter	Scale	Business
Listing	$2.00	$1.20	$0.80	$0.50
Listing details (optional)	$2.00	$1.50	$1.00	$0.80
Seller profile (optional, once per seller)	$1.50	$1.00	$0.80	$0.60

A country comparison row costs about $0.01 each. My test charged 50 listings plus 1 comparison row, which is roughly $0.11 on the Free plan. Listings removed by your title or seller filters are free, and you can set a maximum cost per run so it stops at your limit.

Responsible use

The actor reads public pages only. It does not log in and does not need cookies. Vinted listings belong to real people, most of them private sellers, so keep personal data out of your pipeline unless you have a clear legal basis under GDPR. For price research you rarely need anything beyond price, brand, size, condition and country. I left seller IDs and seller profiles out of the screenshots and the code above for that reason. Keep request volume sensible and read Vinted's terms before you build anything commercial on top of the data.

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