DEV Community: Norbert Sobala

How to scrape 1688.com wholesale prices, MOQ and suppliers with Python

Norbert Sobala — Wed, 11 Nov 2026 08:26:30 +0000

If you sell on Amazon, Shopify or Allegro, the number you care about most is the factory price. For a lot of consumer goods that price lives on 1688.com, the Chinese B2B marketplace run by Alibaba where manufacturers sell to resellers. The site is in Chinese, prices are in yuan, and the useful bits (quantity tiers, minimum order, how long a supplier has been around) are spread over search cards.

This guide shows how to pull that into a table with the 1688 Scraper on Apify, first without code and then with Python and pandas. I tested it on one keyword, 蓝牙耳机 (Bluetooth earphones), with 40 results. Every number below comes from that run.

What the run returned

The run took 82 seconds and saved 40 offers. A few things stood out once the data was in a spreadsheet:

Prices ranged from 6.29 to 54.87 CNY, with a median of 12.0 CNY.
8 of the 40 offers were paid placements (isAd: true). Without them the median drops to about 9.95 CNY, so filter ads out before you average anything.
35 of 40 suppliers were in Guangdong province: 17 in Dongguan and 16 in Shenzhen.
27 suppliers were labelled 生产加工 (manufacturer) and 3 as 经销批发 (trading/wholesale). 10 had no type.
The median supplier had been on 1688 for 3 years. 12 had been there for 5 years or more.
5 offers showed 10,000+ units sold. The top one claimed 100,000.

The tier data is where it gets interesting. One single-ear headset was listed at 12 CNY for 10 to 999 pieces, 4.5 CNY for 1,000 to 2,999 and 4.3 CNY from 3,000 up. The headline price in search was 12 CNY. If you only look at that number, you overestimate your landed cost by more than half at volume.

Fields you get

Field	What it contains
`offerId`, `url`	1688 offer ID and link
`title`, `titleEn`	Chinese title and optional machine translation
`price`, `currency`	Headline price, always CNY
`priceTiers`	List of `{minQuantity, maxQuantity, unit, price}`
`minOrderQuantity`, `unit`	MOQ, filled when the offer shows tiers
`salesCount`, `salesText`, `bookedCount`	Sales figures as shown on the card
`repurchaseRate`	Share of repeat buyers, e.g. `24%`
`supplierName`, `supplierShopUrl`	Company name and shop link
`supplierYearsOn1688`, `supplierType`	Years on the platform, manufacturer or trader
`province`, `city`	Supplier location
`serviceScores`, `serviceTags`	Overall, consultation, logistics, dispute, returns and goods scores, plus verification badges
`isAd`, `page`, `position`	Ranking context

Coverage in my run: titleEn was filled on all 40 offers, serviceScores on 38, repurchaseRate on 28 and minOrderQuantity on 18. MOQ is empty when 1688 does not show quantity tiers on the search card, which is a site limitation, so plan for gaps in that column.

Supplier fields describe companies and their shops. There is no data about private individuals in the output.

Input options

There are only four settings, which keeps it simple:

searchQueries: a list of keywords. Chinese keywords return the most results (手机壳 for phone case, 充电宝 for power bank). English works too, but the hit count is lower.
maxItemsPerQuery: how many offers per keyword, up to about 2,000. That ceiling comes from 1688 search itself.
translateTitles: adds titleEn. It uses a free translation service, so treat it as a rough guide. If the service is down, the field stays empty and the run still finishes.
proxyFallback: on by default. The actor tries without a proxy first and only switches to datacenter and then residential proxy if 1688 blocks it.

Option 1: no code

Open the actor page and click Try for free. You need a free Apify account.
Type your keyword in Search keywords. I used 蓝牙耳机. If you do not read Chinese, Google Translate is good enough to find the right term.
Set Max offers per keyword to something small for a first test, like 40.
Tick Translate titles to English if you want readable titles.
Click Start. A 40 offer run finished in under a minute and a half for me.
Open the Output tab and export as CSV, Excel or JSON.

In Excel, sort by price and hide the rows where isAd is TRUE. That alone gives you a reasonable price range for a product category.

Option 2: Python with pandas

Install the client and pandas:

pip install apify-client pandas openpyxl

The script below runs the actor, drops ads, and works out what each offer costs at 1,000 units using the tier list.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("flarewow/1688-scraper").call(run_input={
    "searchQueries": ["蓝牙耳机"],
    "maxItemsPerQuery": 40,
    "translateTitles": True,
})

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

organic = df[df["isAd"] != True]
print(organic["price"].describe())
print(df["city"].value_counts().head())

def price_at(tiers, qty):
    for t in tiers or []:
        upper = t.get("maxQuantity")
        if t["minQuantity"] <= qty and (upper is None or qty <= upper):
            return t["price"]
    return None

df["price_at_1000"] = df["priceTiers"].apply(lambda t: price_at(t, 1000))

cols = ["titleEn", "price", "price_at_1000", "minOrderQuantity",
        "salesCount", "supplierYearsOn1688", "city"]
shortlist = (df.dropna(subset=["price_at_1000"])
               .sort_values("price_at_1000")[cols])
print(shortlist.head(10))

df.to_excel("1688_bluetooth_earphones.xlsx", index=False)

A few notes from running it:

price_at_1000 is only filled for offers that publish tiers (18 of 40 in my run). For the rest, price is all you have until you message the supplier.
serviceScores is a nested dict. pd.json_normalize(items) flattens it into columns like serviceScores.logistics if you want to filter on it.
Prices exclude shipping inside China and international freight. Add those before you compare with your selling price.

Scheduling and integrations

If you track a category, a weekly run per keyword is usually enough. In the Apify Console, open Schedules, pick the actor and your saved input, and set a cron such as every Monday morning.

From there you can push results onward:

Google Sheets integration to keep a living price sheet.
A webhook to n8n, Make or Zapier when a run finishes.
The Apify MCP server if you want an AI agent to query offers for you.

Each run creates a new dataset, so compare offerId between runs to spot new listings and price changes.

Pricing

The actor charges $2 per 1,000 offers saved to the dataset. My 40 offer test cost $0.08. You only pay for results, and if no offers come back the run ends as failed with an explanation instead of an empty success. Set Max cost per run in the run options if you want a hard cap.

Responsible use

The actor reads publicly visible business listings and needs no login. Keep request volumes reasonable, respect 1688's terms and the law where you operate, and do not treat sales counts as audited figures. They are what the supplier card shows, and a 100,000 sold badge on an 8.99 CNY headset deserves a sample order before you believe it.

If you want to try it, the 1688 Scraper is here. Start with one keyword and 40 results, look at the tiers, then scale up.

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

How to turn EAN codes into Allegro product content with Python and pandas

Norbert Sobala — Mon, 09 Nov 2026 08:31:14 +0000

You have a supplier file with a column of barcodes and a shop that needs titles, descriptions, specs and photos for each of them. Allegro.pl, the largest marketplace in Poland, already has that content for many products sold in the region. This tutorial shows how to pull it by EAN using the Allegro Product Data actor on Apify, either from the browser or from Python.

I tested it with six barcodes on 9 November 2026. Everything below comes from that run, including the part where three of the six results were wrong, which is the most useful thing in this post if you plan to import the data anywhere.

What data you get

One dataset row per EAN. These are the fields I used most, out of 55 in the output:

Field	Example from my run	Notes
`ean`	`5702017584072`	The code you sent
`found`	`false`	Only present on rows with no match
`title`	`LEGO TECHNIC 42173 SZARY HIPERSAMOCHÓD`	Offer title, in Polish
`brand`	`LEGO`	Can be empty
`price`, `currency`	`186.65`, `PLN`	Price of the chosen offer
`categoryPath`	`Dziecko > Zabawki > Klocki > LEGO > Zestawy > Technic`	Full breadcrumb
`parameters`	`{"Liczba elementów": "801", ...}`	Object of spec name and value
`description`	plain text	1,212 characters for the LEGO set
`descriptionHtml`	`<p>...</p>`	Same content with markup
`images`	list of URLs	Capped by `maxImages`
`descriptionImages`	list of URLs	13 for the LEGO set
`productRating`, `productRatingsCount`	`4.97`, `1693`	Product level, across offers
`manufacturerCode`	`MTP63PX/A`	Filled on the iPhone row

The number of parameters varies a lot by category. The iPhone 15 row had 44, the LEGO set 15. Parameter names are in Polish (Waga produktu z opakowaniem jednostkowym is packaged weight), so plan a mapping step if your catalog is in another language.

Main input options

eans: the list of barcodes. This is the required field.
startUrls: Allegro links, if you already know the offer or product page.
marketplace: pl, cz or sk. Applies to EAN lookups; URLs are detected automatically.
productSelection: relevance (default) or popularity, for when one barcode has several offers.
maxImages: 1 to 50 photos per offer, default 10.
descriptionFormat: html (default), text or both.
fetchDescription and fetchParameters: switch these off if you need only one of the two.
downloadImages: stores the photo files in the run's key-value store and returns links in imageFiles. Off by default, and charged per image.

Option 1: no code

Open the actor page and click Try for free.
Paste your barcodes into EAN / GTIN codes, one per line.
Set Description format to HTML + text if you want both versions.
Press Start. My six barcodes took 328 seconds and 21 page requests, so a batch of a few hundred is a job to leave running.
Open the run's results and export as Excel, CSV or JSON. The parameters object arrives flattened into columns in the spreadsheet formats, one per spec name.

Option 2: Python

Install the two libraries:

pip install apify-client pandas

The script below runs the actor and then applies the check that matters, which is comparing the returned brand against the brand you expected.

import pandas as pd
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

expected = {
    "5702017584072": "LEGO",
    "195949036842": "Apple",
    "5449000000996": "Coca-Cola",
    "4006381333931": "STABILO",
    "5901234123457": "Example",
    "3017620422003": "Ferrero",
}

run = client.actor("flarewow/allegro-description-photo-parameters").call(
    run_input={
        "eans": list(expected),
        "descriptionFormat": "both",
        "maxImages": 5,
        "marketplace": "pl",
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
df = pd.DataFrame(items)

hits = df[df["found"] != False].copy()
hits["expected_brand"] = hits["ean"].map(expected)
hits["brand_ok"] = (
    hits["brand"].fillna("").str.lower()
    == hits["expected_brand"].str.lower()
)

clean = hits[hits["brand_ok"]]
review = hits[~hits["brand_ok"]]

columns = ["ean", "title", "brand", "price", "categoryPath", "productRating"]
print(clean[columns])
print(f"Kept {len(clean)} of {len(df)}, {len(review)} to review")
clean.to_csv("allegro_products.csv", index=False)

On my data it printed Kept 2 of 6, 3 to review. The sixth row was the barcode with no match at all.

What the six barcodes returned

EAN	Product I meant	What came back
`5702017584072`	LEGO Technic 42173	Correct. 186.65 PLN, 15 parameters, rating 4.97 from 1,693 ratings
`195949036842`	iPhone 15 256 GB	Correct. 3,667.10 PLN, 44 parameters, rating 4.79 from 107 ratings
`5449000000996`	Coca-Cola	Wrong product: 5 L PET bottles for pickling
`4006381333931`	STABILO point 88	Mixed: STABILO title, but brand `ATS` and a sliding door category
`5901234123457`	GS1 sample barcode	A fishing rod spare part
`3017620422003`	Nutella jar	`found: false`, with the note "No Allegro product with this EAN"

The likely reason is mundane. Sellers enter barcodes into their listings themselves, so a lookup can land on a listing that merely claims that EAN. Food and cheap stationery did badly in my small sample, while a branded toy and a phone came back clean. Six barcodes are too few to generalize from, so treat that as a hint and measure your own catalog.

Checking that parameters["EAN (GTIN)"] equals your input does not help. The STABILO row and the fishing part both passed that test. Brand comparison caught all three bad rows here. If your file has no brand column, compare categoryPath against the category you sell in, or send anything suspicious to a person.

Scheduling and integrations

Product content changes slowly, so a weekly or monthly refresh is plenty. In Apify Console, go to Schedules, add the actor with your saved input and pick a cron expression. A weekly Monday run is 0 6 * * 1.

For moving the results elsewhere, the actor page lists Make, Zapier, n8n, Google Sheets, Slack, Airbyte and webhooks. A webhook on ACTOR.RUN.SUCCEEDED pointing at your import script is enough for a simple PIM feed. You can also call it from an AI agent through the Apify MCP server, which suits the common next step of rewriting scraped descriptions in your own words.

Pricing per 1,000 results

Pay per event, current as of this run:

Event, per 1,000	Free	Starter	Scale	Business and up
Product content resolved	$10.00	$9.00	$8.00	$7.00
Extra image URL, beyond the first 3	$4.00	$0.10	$0.10	$0.10
Image file downloaded, beyond the first 3	$2.00	$1.80	$1.60	$1.50
EAN searched, no match	$1.00	$0.95	$0.90	$0.85

There is also $0.00005 per actor start and $0.01 per 1,000 dataset rows. A resolved product includes the description, parameters and first 3 photos. My run logged 5 resolved products, so about $0.05 on the Free tier. Note that a wrong match counts as resolved, which is another reason to send clean, deduplicated barcodes.

Responsible use

The actor reads public product pages. Rows also carry sellerLogin, sellerUrl and review text in latestReviews, and on Allegro a login can belong to a private individual. If you only need product content, drop those columns before storing anything, because under GDPR you need a legal basis to keep personal data. Descriptions and photos also belong to whoever wrote and shot them, so check the rights before republishing them in your shop, and rewrite the text rather than copying it.

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 Google Play app reviews by star rating and app version with Python

Norbert Sobala — Fri, 06 Nov 2026 08:26:35 +0000

App reviews are free user research. People write them unprompted, they mention the app version, and on Google Play the developer can answer in public. The hard part is getting them out of the store in a shape you can sort and count.

This walkthrough uses the App Store & Google Play Reviews Scraper on Apify. I ran it on Duolingo, US store, only 1 and 2 star reviews with at least 40 characters of text, capped at 25 reviews. Everything below comes from that one run.

What came back from one small run

The run took about 19 seconds. The status line said: 25 reviews, 2 app records, 159 filtered out. So the scraper read 184 recent reviews and kept the 25 that matched my rules. You only pay for the 25.

A few things I noticed in those 25 reviews:

13 were 1 star, 12 were 2 star. The sentiment label said "negative" for all 25.
They were all posted on November 5, 2026, within roughly five hours. Duolingo gets a lot of reviews.
11 reviews came from version 6.103.6 and 9 from 6.104.5. Three had no version at all.
None had a developer reply yet. That makes sense for reviews a day old.
7 of 25 mentioned streaks, 5 mentioned AI, 3 mentioned ads, 3 mentioned price. One person described a refund problem after upgrading to Duolingo Max.
Median review length was 351 characters. These are not one-word rants.

The app records are useful context. Google Play listed Duolingo at 4.75 stars from 51,650,385 ratings, 500M+ installs, last updated 2026-11-03. The App Store record showed 4.72 stars from 5,565,332 ratings and version 7.147.1.

That contrast is the reason to filter. A 4.75 average tells you nothing about what annoys people this week. Twenty-five recent low ratings, grouped by version, do.

Fields you get

Each review is one row. App details, if you turn them on, are separate rows with recordType: "app".

Field	What it holds
`recordType`	`review` or `app`
`store`	`google_play` or `app_store`
`appId`, `appName`	Package name or Apple ID, plus the store title
`country`, `language`	Store country and review language
`rating`	1 to 5 stars
`sentiment`	`negative`, `neutral` or `positive`
`title`, `text`	Review title (App Store) and body
`date`	When the review was posted (ISO timestamp)
`appVersion`	Version the reviewer had installed
`thumbsUp`	"Helpful" votes
`developerReply`, `developerReplyDate`	The public answer, Google Play only
`url`	Direct link to the review
`userName`	Reviewer display name. Treat as personal data (see the last section)

App rows carry developer, rating, ratingsCount, installs (Google Play), price, category, contentRating, updated, icon and url.

Input options that matter

You can paste store links, an app ID like com.duolingo, or just a name like Duolingo. A name is looked up in both stores. There is also searchTerms, which takes a keyword such as meditation and scrapes the top N apps for it (maxAppsPerSearch, default 5).

The rest is filtering:

countries: two-letter codes. Reviews are collected per country, so ["us", "gb", "de"] gives three separate sets.
maxReviewsPerApp: per app and per country, counted after filters. 0 means everything available.
sort: newest, most_relevant or rating.
minRating / maxRating: set maxRating: 2 for complaints only.
reviewsSince: a date, handy for weekly reports.
keywords: keep reviews that mention any of these words, like crash or login.
appVersion: version prefix such as 6.104. This is the one I use most for release checks.
developerReply: with, without or any. without gives you a support queue.
minThumbsUp and minTextLength: drop noise.
onlyNewReviews plus monitorId: for scheduled runs, return only reviews you have not seen before.

Two limits from the README. Apple publishes only the latest 500 reviews per app and country, so add countries if you need more. Developer replies exist only on Google Play.

Option 1: no code

Open the actor page and click Try for free.
Under Apps, type Duolingo or paste a Play Store link.
Pick the US in Countries and set Max. reviews per app and country to 25.
Set Max. rating to 2 and Min. review length to 40.
Leave Include app details on if you want the rating and install numbers.
Click Start. When it finishes, open the dataset and export to CSV, Excel or JSON.

On a free Apify account this is enough to test a hypothesis in a couple of minutes.

Option 2: Python with apify-client and pandas

Install the two packages:

pip install apify-client pandas

Then run the actor and load the reviews into a DataFrame. Put your Apify token in an environment variable, not in the script.

import os
from apify_client import ApifyClient
import pandas as pd

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

run_input = {
    "apps": ["com.duolingo"],
    "countries": ["us"],
    "language": "en",
    "maxReviewsPerApp": 25,
    "sort": "newest",
    "maxRating": 2,
    "minTextLength": 40,
    "includeAppDetails": True,
}

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

df = pd.DataFrame(items)
reviews = df[df["recordType"] == "review"].drop(columns=["userName", "userImage"], errors="ignore")
apps = df[df["recordType"] == "app"]

print(apps[["store", "appName", "rating", "ratingsCount", "installs", "updated"]])

# Low ratings per app version
print(reviews.groupby("appVersion", dropna=False)["rating"].agg(["count", "mean"]))

# Which topics come up (also matches plurals)
topics = ["streak", "ai", "ads", "price", "subscription", "refund"]
text = reviews["text"].str.lower()
counts = {t: int(text.str.contains(rf"\b{t}s?\b", regex=True).sum()) for t in topics}
print(counts)

reviews.to_csv("duolingo_negative_reviews.csv", index=False)

On my run the version table showed 11 rows for 6.103.6 and 9 for 6.104.5, and the topic counter gave streak 7, ai 5, ads 3, price 3. Note that I drop userName and userImage right after loading. You rarely need them for analysis.

If you want to compare competitors, put several apps in apps and add appName to the groupby. If you want to compare markets, add countries and group by country.

Scheduling and integrations

For ongoing monitoring, save the input as a task and add a schedule, for example daily at 07:00. Turn on onlyNewReviews and give the monitor a name like duolingo-negative. Each run then returns only new reviews, and the README says reviews already returned are not charged again.

From there you can send the dataset to Google Sheets, post a Slack message through a webhook, or hook it into Make, Zapier or n8n. A setup I like: daily run, maxRating: 2, developerReply: "without", results posted to a support channel.

Pricing

The actor uses pay-per-event pricing, platform usage included. Current prices:

Event	Free	Starter	Scale	Business
1,000 reviews	$0.20	$0.18	$0.165	$0.15
App details (per app and country)	$0.002	$0.002	$0.002	$0.002

There is also a start fee of $0.00005 per GB of memory. My run produced 25 reviews and 2 app records, so on the Free tier that is about $0.005 for reviews plus $0.004 for app details. Reviews dropped by filters are not charged.

Responsible use

Reviews are public, but the people who wrote them are private individuals. Their display names and avatars count as personal data under GDPR. Drop those columns unless you have a clear reason to keep them, and never publish them. Quote review text without names, as I did above. Keep request volumes reasonable and follow the stores' terms.

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 Workday career sites for jobs and pay ranges with Python

Norbert Sobala — Wed, 04 Nov 2026 08:34:40 +0000

Plenty of large employers run their careers page on Workday. NVIDIA, Boeing, Intel, Cisco and Pfizer all do, and the URLs end in myworkdayjobs.com. The job lists look the same everywhere, which is handy: one scraper covers all of them.

I used the Workday Jobs Scraper on Apify to pull "data engineer" openings from NVIDIA and Boeing. One run returned 40 postings with full descriptions and pay ranges in 15.7 seconds. Below is the setup, the code, and what the data looked like.

What data you get

Each row is one job posting. These are the fields I used the most:

Field	What it holds	Example from my run
`jobId`	Workday requisition ID	`JR2028539`
`title`	Job title	Senior Staff Software Engineer - Data Engineering
`company`	Workday tenant name	Nvidia
`hiringEntity`	Legal entity that hires	Boeing Poland sp. z o.o. EFS
`location`, `allLocations`, `country`	Main location, every location of a multi-site job, country	US, CA, Santa Clara
`remoteType`	Employer's own remote/hybrid/onsite label	Onsite Job
`employmentType`	Full time or part time	Full time
`postedText`, `postedDate`	"Posted X days ago" and the exact date	2026-10-30
`salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`	Pay range parsed from the posting	200000 / 322000 / USD / year
`description`	Full job text	about 5,900 characters on average
`url`, `applyUrl`	Job page and apply page
`careerSiteUrl`, `workdayTenant`	Which Workday site it came from	boeing.wd1.myworkdayjobs.com

Postings are company data. There are no applicant profiles or personal data in the output.

What one small run returned

Input: two companies, search text data engineer, posted in the last 30 days, 20 jobs per company.

40 jobs saved, 20 per company, all full time.
Posting dates from 2026-10-14 to 2026-11-03.
33 of 40 had a published pay range (NVIDIA 19 of 20, Boeing 14 of 20). 32 in USD, one in CAD from Boeing Vancouver.
Median USD range: NVIDIA $168,000 to $264,500, Boeing $126,650 to $171,350.
14 postings listed more than one location. One Boeing role listed 16 US sites.
Countries: 34 US, 2 UK, and one each for India, Poland, Canada and Ethiopia.

The jobs without a pay range were mostly outside the US, which matches how pay-transparency laws work. One more detail I liked: a Boeing posting wrote its range as "$72.250 - $104,650" (note the dot), and the scraper still parsed salaryMin as 72250.

Main input options

Companies. One per line. A Workday URL is the safest choice, for example https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite. You can also type a name (Boeing) or a website (intel.com), and the actor tries to find the career site. I typed Boeing and it resolved to boeing.wd1.myworkdayjobs.com/EXTERNAL_CAREERS without help. Auto-detection does not work for every company. When it fails, the log says so and you paste the URL.
Search text. Sent to Workday's own search. Leave it empty to get every job.
Location contains. Plain text match on the location, such as Germany, London or TX.
Posted within last N days. 0 means any date.
Max jobs per company. Workday returns at most about 2,000 results per search, so split big employers with search text.
Include full description. On by default. It opens each job to get the description, all locations, exact date and pay range. Turn it off if you only need titles and links.
Only new jobs. Each run returns only postings that earlier runs with the same company and search text did not return.

Option 1: no code

Open the actor page and click Try for free.
In Companies, add the career site URLs or names you care about.
Set Search text (I used data engineer) and Posted within last N days (30).
Set Max jobs per company to something small for a first test, like 20.
Click Start. My run finished in 16 seconds.
Open the Output tab and export to Excel, CSV, JSON or HTML.

No proxy is needed. Workday's public job API answered fine without one, and the proxy option is off by default.

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 into a DataFrame:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "companies": [
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "Boeing",
    ],
    "searchText": "data engineer",
    "postedWithinDays": 30,
    "maxJobsPerCompany": 20,
    "includeDescription": True,
}

run = client.actor("flarewow/workday-jobs-scraper").call(run_input=run_input)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
df = pd.DataFrame(items)

print(len(df), "jobs")

# Pay ranges in USD, per company
usd = df[df["salaryCurrency"] == "USD"]
print(usd.groupby("company")[["salaryMin", "salaryMax"]].median())

# Share of postings with a published range
print(df.groupby("company")["salaryMin"].apply(lambda s: s.notna().mean()))

# Multi-location jobs
df["n_locations"] = df["allLocations"].apply(
    lambda v: len(v) if isinstance(v, list) else 1
)
print(df.sort_values("n_locations", ascending=False)[["title", "n_locations"]].head())

df.drop(columns=["description"]).to_csv("workday_jobs.csv", index=False)

On my data the first groupby printed the medians above. The description column is long, so I drop it before saving a CSV for a spreadsheet, and keep it in the DataFrame for keyword searches like df[df.description.str.contains("Spark", case=False)].

Scheduling and integrations

For monitoring, turn on Only new jobs and create a Schedule in Apify Console, for example daily at 7:00. Each run then returns only postings that earlier runs have not seen, and you pay only for those.

From there you can send results to Google Sheets, Slack, Airtable, n8n, Make or Zapier through Apify integrations, or point a webhook at your own endpoint. A setup I'd use for recruiting: one task per target company, daily schedule, new rows appended to a sheet that the team filters by location.

If a run cannot scrape any company, it ends as Failed with a message instead of an empty success. A RUN_SUMMARY record in the key-value store lists the status of each company, which makes failed schedules easy to spot.

Pricing

The actor uses pay per result: $1.50 per 1,000 jobs, plus a start fee of $0.00005 per run. Platform usage is included. You are charged only for jobs saved to the dataset, so a company that is not found costs nothing. My 40-job test cost about six cents.

Responsible use

The actor reads public job postings that companies publish on their own Workday career sites. It does not log in and does not collect applicant data. Keep volumes reasonable, respect Workday's and the employers' terms, and if you republish postings, link back to the original job page.

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