Allegro Listing Lookup — Price, Condition & Rating API

Look up any Allegro.pl listing by URL and get back structured product data — name, brand, price, condition, availability, and seller rating — pulled straight from the listing page's own schema.org JSON-LD. Allegro is protected by DataDome, so this actor routes through a real browser session on Apify's UNBLOCKER proxy group to get past the challenge that blocks plain HTTP requests.

Who it's for

The accountable_eel catalogue also covers single-listing lookups on marketplaces that don't publish an open API. Each actor takes a list of listing URLs and returns one flat, stably-named row per input — price, condition, availability, seller signal — read from the listing page's own schema.org structured data rather than from CSS selectors that move with every redesign. Pricing is pay-per-event and per-listing: a few tenths of a cent for a listing that actually resolved, and nothing for a removed listing, a 404, or a page with no product data. No seat licence, no monthly minimum, no credit system to decode. This one covers Allegro.pl, Poland's dominant marketplace — the hard part isn't the parsing, it's getting past DataDome at all.

Why this one

• Reads Allegro's own structured data, not a scrape of rendered HTML. Every listing page ships a schema.org Product JSON-LD block. That's what this actor parses — no CSS selectors to break when Allegro reskins the page.
• It actually gets past DataDome. A plain residential proxy with browser-like headers gets the same 781-byte block page as bare curl. This actor uses Apify's UNBLOCKER proxy group, which defeats the challenge reliably.
• You don't pay to find out "gone." A removed listing, an invalid URL, a 404, or a page without product data comes back found: false and is never billed.
• Bare slugs or full URLs. Pass a full allegro.pl/oferta/... URL or just the slug/id — the actor builds the URL for you, so you don't need to clean the list first.
• Stably-named fields. Field names are frozen between runs, which matters if you're wiring this into an AI agent or a Clay column that reads the schema once and keeps using it.

What you get

One row per input listing. Every field below is stably named and won't be renamed between runs.

Field	Type / format	Description
query	text	The listing URL or slug exactly as submitted, before normalization.
found	boolean	Whether the page returned a schema.org Product block with an offers object. Gates billing — false rows are never charged.
scrapedAt	date (ISO 8601)	When the listing was read.
data.name	text	Product title as shown on the listing.
data.brand	text	Brand name, flattened from either the string or object form of schema.org brand.
data.sku	text	Allegro's offer id — the numeric suffix on the /oferta/ URL.
data.gtin	text	Global Trade Item Number (EAN/UPC) where the seller supplied one. Frequently null — many Allegro sellers don't fill it in.
data.description	text	Listing description from the JSON-LD block.
data.image	link	URL of the listing's primary image.
data.price	text	Current price as a string, no currency symbol.
data.priceCurrency	text	ISO currency code — PLN for allegro.pl.
data.itemCondition	text	NewCondition, UsedCondition, or RefurbishedCondition (schema.org prefix stripped).
data.availability	text	InStock, OutOfStock, or SoldOut (schema.org prefix stripped).
data.ratingValue	number	Aggregate seller/product rating, typically 0–5. null when the listing has no reviews.
data.ratingCount	number	Number of ratings behind ratingValue. null when there are none.
data.url	link	Canonical listing URL from the offer, falling back to the resolved page URL.

Three dataset views are set up in the Console: Overview (what was checked), Price and availability, and Seller rating.

Price

$4 per 1,000 results, plus a $0.08 start fee. Misses (found:false) are never charged.

You're billed per listing that actually resolved to product data. A removed listing, a 404, an invalid URL, or a redirect to Allegro's separate allegrolokalnie.pl sub-brand costs nothing. Run 1,000 listings and, at the live FREE-tier per-row price, that's roughly $4 if every one of them resolves — less as some turn out to be gone, and less again on paid Apify plans where the per-row price drops.

The $0.08 start fee is higher than most Allegro actors on the Store, and that's deliberate: every request here is a full headless browser session through UNBLOCKER, which is billed by compute time. The fee is per run, not per listing — so it's noise on a batch of 500 and material if you run one listing at a time. Batch your lookups.

How to use

1. In the Apify Console. Open the actor page and click Start — the items field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. Via the API. Call it directly with a POST request — no Console needed once you have an API token:

   curl "https://api.apify.com/v2/acts/accountable_eel~allegro-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"items":["https://allegro.pl/oferta/fotel-obrotowy-sense7-czarny-16352245834"]}'
   

3. On a schedule. Save this actor as an Apify Task with the input you want, then add a Schedule (hourly, daily, weekly) so it runs on its own — no server of your own required.

1. Paste your listing URLs into items — full allegro.pl/oferta/... URLs or bare slugs/ids, mixed formats are fine.
2. Run the actor. Each listing is opened in a real browser session through UNBLOCKER, up to maxConcurrency at a time.
3. Read the dataset. Each row carries the parsed data object, or found: false if the listing no longer resolves.
4. Filter to found: true before you export if you only want live listings — misses are still written so you can see what was checked, but were never charged.

Common ways teams use this:

• Track price and stock across a watchlist of Allegro listings by re-running on a schedule and diffing price and availability between runs.
• Check seller credibility before referencing or reselling a listing — ratingValue and ratingCount come from Allegro's own aggregate data.
• Enrich a product catalog with live condition and availability for SKUs you already track elsewhere.
• Verify a listing is still live before sending it to a customer or publishing it in a comparison table.
• Feed listing URLs in from another source — a search export, a marketplace crawl, a supplier feed — and get a clean structured lookup step at the end of the pipeline.

Input

{
  "items": [
    "https://allegro.pl/oferta/drewnochron-lakier-alkilak-polysk-5l-domalux-12787105059"
  ],
  "maxConcurrency": 2
}

items is the list of Allegro listing URLs to look up. Three formats all resolve to the same lookup, and you can mix them freely in one run:

• a full URL — https://allegro.pl/oferta/drewnochron-lakier-...-12787105059
• the bare slug — drewnochron-lakier-alkilak-polysk-5l-domalux-12787105059
• a /produkt/ canonical URL, which the listing's own JSON-LD points back to

maxConcurrency controls parallel browser sessions and defaults to 2, with a hard ceiling of 5. Keep it low: each session is a full headless browser through UNBLOCKER, billed by compute time, so raising it makes a batch finish sooner rather than cost less. Duplicate items in the same run are each looked up and each charged — de-duplicate your list first if that matters. There's no cap on how many items you can pass in a single run.

Sample output

One row per listing, for example:

{
  "query": "https://allegro.pl/oferta/drewnochron-lakier-alkilak-polysk-5l-domalux-12787105059",
  "found": true,
  "data": {
    "name": "Drewnochron lakier alkilak połysk 5L Domalux",
    "brand": "Domalux",
    "sku": "12787105059",
    "gtin": null,
    "description": "Lakier do drewna...",
    "image": "https://a.allegroimg.com/...",
    "price": "89.99",
    "priceCurrency": "PLN",
    "itemCondition": "NewCondition",
    "availability": "InStock",
    "ratingValue": 4.8,
    "ratingCount": 132,
    "url": "https://allegro.pl/oferta/drewnochron-lakier-alkilak-polysk-5l-domalux-12787105059"
  },
  "scrapedAt": "2026-08-20T12:00:00.000Z"
}

A listing that no longer resolves comes back as a miss, with data omitted entirely:

{
  "query": "https://allegro.pl/oferta/removed-listing-99999999999",
  "found": false,
  "scrapedAt": "2026-08-20T12:00:04.000Z"
}

Four things produce a miss, and none of them are billed: a removed or expired listing, an invalid URL or bad slug, a 404, and a page that redirects to Allegro's separate allegrolokalnie.pl classifieds sub-brand — a different page shape with no Product schema, out of scope for this actor.

Miss rows are still written to the dataset so you can audit exactly which inputs failed rather than diffing your input list against the output. Filter to found: true when you export if you only want live listings.

Three dataset views are wired up in the Console so you don't have to flatten data yourself: Overview (query, found, scrapedAt — what was checked), Price and availability (product, brand, price, currency, condition, availability), and Seller rating (product, rating, rating count, listing URL). Each is exportable to CSV, JSON, or Excel straight from the run page.

Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

curl "https://api.apify.com/v2/acts/accountable_eel~allegro-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"items":["https://allegro.pl/oferta/fotel-obrotowy-sense7-czarny-16352245834"]}'

n8n. Add an HTTP Request node: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~allegro-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body Content Type JSON, JSON Body {"items":["https://allegro.pl/oferta/fotel-obrotowy-sense7-czarny-16352245834"]} (swap in an expression from an earlier node for a real value).

Clay. Add an "HTTP API" column: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~allegro-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body {"items":["{{value}}"]}, mapping the row's value into the items array.

MCP. In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Allegro Listing Lookup | Apify" — the agent will find and run this actor.

Tips

• Batch your listings into one run. The $0.08 start fee is charged per run, not per listing. One run of 500 listings costs one start fee; 500 runs of one listing cost 500.
• Keep maxConcurrency at 2–3 unless you've measured. Each session is a full headless browser through UNBLOCKER, billed by compute time. Raising it to 5 doesn't make a batch five times cheaper — it makes it finish sooner and cost more.
• Don't expect gtin to be populated. Many Allegro sellers leave it blank. If you're matching against a product catalog, use sku (the offer id) plus name, and treat gtin as a bonus when it's there.
• Use /produkt/ URLs to find the /oferta/ one. If your list has allegro.pl/produkt/...?offerId=N canonical URLs, those pages link to the corresponding /oferta/ page inside their own JSON-LD.
• Filter to found: true before you export. Misses still take a dataset row so you can audit what was checked, but you rarely want them in a downstream table.
• Re-run on a schedule and diff the rows to catch price drops or a listing going OutOfStock on a competitor watchlist.

vs. alternatives

	What it costs	What you get	Trade-off
This actor (allegro-listing-lookup)	$4 per 1,000 resolved listings (less on paid tiers), $0.08 actor start, nothing for a removed or invalid listing	Structured price, condition, availability, brand, SKU and seller rating for a listing URL you already have, read from the page's own JSON-LD	Takes listing URLs only — it won't search or crawl categories for you, and the per-run start fee is high because every request is a real browser session
e-commerce/allegro-fast-product-scraper (620 users)	$5 per 1,000 listings, $0.0001 start	Crawls category and search pages, so it discovers listings rather than requiring URLs	If you need to find listings rather than look up known ones, this is the shape you want. Rated 1.14/5 at the time of writing — check current reviews before committing a batch.
e-commerce/allegro-product-detail-scraper (390 users)	$5 per 1,000 detail pages, $0.0001 start	Per-listing detail extraction, the closest direct comparison to this actor	Cheaper to start, more expensive per row. Worth benchmarking side by side on your own list.
memo23/allegro-scraper (145 users)	$3 per 1,000 products, $0.005 start	Cheapest per row of the four, with a broad field set	Lowest per-row price here — if your batches are large and you don't need the miss-is-free guarantee, run the numbers.
Doing it yourself	Your time + a headless browser fleet, plus solving DataDome, its retries, and its transient 502s	The same data	This actor absorbs the UNBLOCKER routing, the retry logic, the concurrency ceiling and the JSON-LD parsing. DataDome is the whole difficulty; everything after it is twenty lines.

Competitor prices are their published FREE-tier list prices as of August 2026 and are not tracked here — check the actor's own page before relying on the comparison.

FAQ

What counts as "found"? The listing page must contain a schema.org Product JSON-LD block with an offers object. Removed listings, 404s, and pages without that structured data return found: false and are never charged.

Why does this need a real browser instead of a plain HTTP request? Allegro is protected by DataDome. A plain residential proxy with browser-like headers gets the same block page as a bare request — this actor routes through Apify's UNBLOCKER proxy group specifically because it reliably defeats that challenge.

Can I use search-result or category pages instead of listing URLs? No — search pages are client-rendered with no usable product data in the page source. Only individual listing pages (allegro.pl/oferta/...) carry the structured JSON-LD this actor reads. If you have allegro.pl/produkt/...?offerId=N canonical URLs, those pages link to the corresponding /oferta/ page in their own JSON-LD.

Why is maxConcurrency capped so low? Each concurrent request is a full headless browser session through UNBLOCKER, which is billed by compute time. Keeping concurrency at 2–5 balances throughput against cost.

Why is the start fee $0.08 when other Allegro actors charge a fraction of a cent? Because those actors use plain HTTP requests and this one runs a real browser through UNBLOCKER to get past DataDome. The fee is per run — batch your listings and it amortizes to nothing.

What happens on a transient error? Apify's UNBLOCKER infrastructure occasionally returns transient 502s unrelated to Allegro itself; the actor retries automatically (up to 3 times) before giving up on an item.

Does this work for allegrolokalnie.pl classifieds? No — that's a separate sub-brand with a different page shape and no Product schema. It's out of scope for this actor.

Does it work on allegro.cz, allegro.sk or allegro.hu? Not currently. The actor is configured for allegro.pl with a Polish proxy country and locale.

Is the price live or cached? Live. Every row is a fresh page load at run time — nothing is stored between runs.

Can I get more than one price point, or price history? No. Each row is a single reading at run time — nothing is stored between runs. To build history, save the actor as a Task, put it on a Schedule, and diff the datasets between runs.

Why is brand sometimes missing when the listing clearly shows one? brand is read from the seller's own structured data. Allegro doesn't force sellers to fill it in, and some listings put the brand only in the free-text title. When that happens brand is null and you can still recover it from name.

Does a run fail if some listings are unreachable? No. Items are independent — an unreachable listing becomes a found: false row and the run continues through the rest of the batch. A run only fails on a platform-level error, not on a bad item.

Is scraping Allegro listings legal? This actor reads publicly accessible listing pages and the schema.org structured data those pages publish for search engines — it doesn't log in, doesn't touch personal data, and doesn't bypass a paywall. That said, the legality of any particular use depends on your jurisdiction and what you do with the data; Allegro's terms of service apply to you as the operator of the run. Take your own legal advice if you're deploying this commercially.

Related actors

• Idealista Listing Lookup — the same listing-lookup shape for Idealista property listings in Spain, Portugal and Italy.
• Open Food Facts Product Lookup — product data by barcode when you have a GTIN rather than a marketplace URL.
• Shopify Store Lookup — live product catalogs for merchants running their own Shopify storefront.

Po polsku

Allegro Listing Lookup pobiera dane z dowolnej oferty Allegro.pl na podstawie linku: nazwa, marka, cena, stan (nowy / używany), dostępność oraz ocena sprzedawcy. Dane pochodzą bezpośrednio ze struktury schema.org JSON-LD samej strony oferty, a nie z parsowania HTML. Actor przechodzi przez zabezpieczenie DataDome dzięki przeglądarce na proxy UNBLOCKER. Płacisz wyłącznie za oferty, które faktycznie się rozwiązały — usunięte oferty i błędne linki są bezpłatne.

Słowa kluczowe: Allegro API, scraper Allegro, monitoring cen Allegro, pobieranie ofert Allegro, dane produktowe Allegro, sprawdzanie dostępności, ocena sprzedawcy.