# Allegro Listing Lookup — Price & Availability API (`accountable_eel/allegro-listing-lookup`) Actor

Look up any Allegro.pl listing by URL: name, brand, price, condition, availability, and seller rating from the listing's own structured data, via a real browser session to get past DataDome protection. Charged only for listings that resolve — never for removed or invalid URLs.

- **URL**: https://apify.com/accountable\_eel/allegro-listing-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 successful lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Allegro Listing Lookup — Price, Condition & Rating API

Look up any [Allegro.pl](https://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:
   ```bash
   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

```json
{
  "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:

```json
{
  "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:

```json
{
  "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.

```bash
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](https://apify.com/accountable_eel/idealista-listing-lookup) —
  the same listing-lookup shape for Idealista property listings in Spain, Portugal and Italy.
- [Open Food Facts Product Lookup](https://apify.com/accountable_eel/openfoodfacts-product-lookup) —
  product data by barcode when you have a GTIN rather than a marketplace URL.
- [Shopify Store Lookup](https://apify.com/accountable_eel/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.*

# Actor input Schema

## `items` (type: `array`):

One item per line — see the item shape and examples below. Only the items we actually find are charged — never per run, and never for a miss.

## `maxConcurrency` (type: `integer`):

Parallel browser sessions. Keep low — each session is a full headless browser through UNBLOCKER, more sessions at once multiplies compute cost fast.

## Actor input object example

```json
{
  "items": [
    "https://allegro.pl/oferta/fotel-obrotowy-sense7-czarny-16352245834"
  ],
  "maxConcurrency": 2
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "items": [
        "https://allegro.pl/oferta/fotel-obrotowy-sense7-czarny-16352245834"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/allegro-listing-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "items": ["https://allegro.pl/oferta/fotel-obrotowy-sense7-czarny-16352245834"] }

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/allegro-listing-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "items": [
    "https://allegro.pl/oferta/fotel-obrotowy-sense7-czarny-16352245834"
  ]
}' |
apify call accountable_eel/allegro-listing-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/allegro-listing-lookup"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gPFzIxsy0NYaAK6Wd/builds/otjwAYvZ2gcBWH9Ei/openapi.json