# Allegro Scraper \[Only $0.0014πŸ’°] | Prices | Sellers | GTIN (`ahmed_jasarevic/allegro-scraper`) Actor Scrape Allegro.pl product data by keyword, category, seller or offer URL β€” pure HTTP, no browser. Each row: price, seller reputation, condition, parameters, Smart!/sponsored flags and sales velocity. Deep mode adds stock, GTIN and warranty. - **URL**: https://apify.com/ahmed\_jasarevic/allegro-scraper.md - **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community) - **Categories:** - **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.40 / 1,000 results 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 Scraper β€” Prices, Sellers, Stock & GTIN Data from Allegro.pl Extract **Allegro.pl product listings in bulk** β€” Poland's #1 marketplace (~20M active offers). Search by keyword, category, seller storefront or direct offer URL and get one clean row per product: **price (current + pre-discount), seller reputation, condition, parameters, images, Smart!/sponsored flags, stock, GTIN/EAN and real sales-velocity data** β€” for **Allegro price monitoring, competitive analysis and Polish e-commerce market research**. Pure HTTP, no browser, no OAuth β€” each row is normalized, deduplicated and tagged with its source query. ### Main Use Cases - **Allegro price monitoring** β€” track current, original (pre-discount) and delivery-inclusive prices over time with scheduled runs. - **Competitive analysis of Polish e-commerce** β€” seller reputation (positive feedback %, Super Seller), sponsored vs organic placement, and how many sellers carry the same product (`productOffersCount`). - **GTIN/EAN barcode lookup** β€” enrich or price-check product catalogs via `barcodeQuickLookup` (up to ~6,000 products per query). - **Market research on Poland's largest marketplace** β€” retrieve full category trees, cheapest-to-expensive ranges and sales-velocity signals (`popularity.buyersQuantity`). - **Seller storefront and assortment analysis** β€” pull a seller's entire catalog (storefront URLs have no 100-page cap). - **Stock and availability tracking** β€” deep mode adds exact stock quantity, warranty and return policy per offer. ### How To Extract Allegro.pl Product Data The actor requests the same listing and offer pages your browser does, reads the JSON Allegro embeds in each page (no headless browser), paginates and dedupes for you. 1. **Bypass the DataDome anti-bot wall** via Apify Proxy (warmup mode or UNBLOCKER) or a scrape.do API key. 2. **Read the embedded JSON** β€” `__listing_StoreState` on listing pages; `formattedPrice`, `sellerName`, `aggregateRating`, `galleryItems` and `parameters` blocks on offer pages. 3. **Paginate and dedupe** by `offerId`, respecting `maxItemsPerQuery` / `maxPagesPerQuery`. 4. **Optionally go deep** β€” with `scrapeProductDetails` the actor visits each `/oferta/` page and merges the rich offer dataset onto the row. 5. **Normalize** β€” one record per product, tagged with its source query/URL and scrape timestamp. ### Monitor Allegro Prices and Competitor Offers Allegro only embeds part of the product data in search results. This actor surfaces **signals competitors don't expose** straight from the listing: - **Sales velocity** β€” `popularity.buyersQuantity` ("562 osoby kupiΕ‚y ostatnio"). - **Original (pre-discount) price** β€” see when prices are artificially inflated before a discount. - **`productOffersCount`** β€” how many sellers list the same product (competitive pressure on the catalog page). - **Smart! eligibility, sponsored vs organic flags, free delivery/free-return flags.** Schedule the run daily or weekly and store each dataset separately to build a **price history feed**: with `priceWithDelivery` (cheapest total including delivery) you monitor what the buyer actually pays, not just the sticker price. ### Search Allegro by Keyword, Category, Seller or Offer URL Four input modes, auto-detected and freely mixed in one run: | Input | Example | What you get | |---|---|---| | **Search query** | `laptop gaming` | Every matching offer, paginated, with price/condition/sort filters | | **Category URL** | `https://allegro.pl/kategoria/laptopy-491` | The full category, paginated | | **Seller storefront** | `https://allegro.pl/uzytkownik/Kong` | Every offer from one seller (uncapped) | | **Offer URL** | `https://allegro.pl/oferta/18581001532` | A single product (always full detail) | A `p=N` in a listing/category/seller URL is respected β€” the crawl starts there and continues forward, so you can split a huge storefront into page batches (`?p=1`, `?p=101`, …). The official Allegro REST API is OAuth-gated and **seller-scoped** β€” it requires an Allegro seller account, access tokens and grant permissions, and isn't usable for public market research. This actor needs **no API key**: it replaces the paid API for keyword, category, seller and offer data extraction. ### Allegro Product Data and Sales-Velocity Signals (Output) One row per product, pushed to the default dataset. **Listing fields are always present**; the `detail` object is populated in deep mode (or for direct offer URLs). ```json { "offerId": "18301984000", "productId": "8e2abfdd-4b19-4384-beee-7d9c5f8dadd6", "url": "https://allegro.pl/oferta/szklo-hartowane-9h-iphone-15-18301984000", "title": "SzkΕ‚o hartowane KONG do Apple iPhone 15, iPhone 16 1 szt.", "brand": "KONG", "price": { "amount": 14.99, "currency": "PLN" }, "originalPrice": { "amount": 19.99, "currency": "PLN" }, "priceWithDelivery": { "amount": 25.48, "currency": "PLN" }, "condition": "Nowy", "seller": { "id": "142221614", "login": "Kong", "company": true, "superSeller": true, "positiveFeedbackPercent": 100, "url": "https://allegro.pl/uzytkownik/Kong" }, "sponsored": true, "smart": true, "productOffersCount": 1, "popularity": { "label": "562 osoby kupiΕ‚y ostatnio", "buyersQuantity": 562 }, "rating": { "value": 4.9, "count": 97 }, "parameters": [ { "name": "Stan", "value": "Nowy" }, { "name": "Marka", "value": "KONG" } ], "images": ["https://a.allegroimg.com/s512/116f16/…"], "searchQuery": "iphone 15", "scrapedAt": "2026-09-07T12:00:00.000Z", "detail": { "stock": { "available": 3689, "label": "z 3 689 sztuk", "unit": "UNIT" }, "gtin": "5907494722515", "rating": { "value": 4.9, "count": 97, "reviewsCount": 39, "distribution": [ { "score": 5, "count": 90, "percentage": 93 } ] }, "returnPolicy": { "withdrawalPeriod": "14 dni", "costLabel": "KupujΔ…cy lub za darmo dla wybranych metod Smart!" }, "warranty": { "period": "24 miesiΔ…ce", "type": null, "label": "24 miesiΔ…ce producenta/dystrybutora" }, "breadcrumbs": ["Allegro", "Elektronika", "Telefony i Akcesoria", "Folie i szkΕ‚a ochronne"], "parameterGroups": [ { "group": "Dane podstawowe", "parameters": [ { "name": "Stan", "value": "Nowy" } ] } ], "description": "SzkΕ‚o hartowane 9H KONG dopasowane do Apple iPhone 15, iPhone 16…", "images": ["https://a.allegroimg.com/original/…"] } } ``` #### Key output fields | Field | Description | |---|---| | `offerId` | Allegro offer id β€” stable key, `allegro.pl/oferta/{offerId}` resolves to the offer | | `productId` | Allegro product (catalog) id β€” the same product across many sellers | | `price` Β· `originalPrice` | Current price and pre-discount price (PLN), when on sale | | `priceWithDelivery` Β· `delivery` | Total with cheapest delivery; free-delivery / free-return flags; lowest delivery cost | | `seller` | id, login, company flag, **Super Seller**, **positiveFeedbackPercent**, storefront URL | | `sponsored` Β· `promoted` Β· `smart` | Ad context and Allegro Smart! eligibility | | `productOffersCount` | How many sellers offer the same product | | `popularity.buyersQuantity` | Recent buyers β€” a real **sales-velocity** signal | | `rating` | Average stars + rating count | | `detail.stock` Β· `detail.gtin` | Exact available quantity and GTIN/EAN barcode (deep mode) | | `detail.warranty` Β· `detail.returnPolicy` | Warranty period/type and return terms (deep mode) | | `detail.description` Β· `detail.parameterGroups` | Full description and grouped spec table (deep mode) | The dataset schema (`.actor/dataset_schema.json`) defines **two output views**: *Overview* (price/competitor quick view) and *Full details* (deep-mode fields: stock, GTIN, warranty, returns). ### Input Configuration | Field | Type | Required | Default | Notes | |---|---|---|---|---| | `searchQueries` | array | no | `["laptop gaming"]` | Keywords to search; each runs its own paginated crawl | | `startUrls` | array | no | β€” | Direct offer / search / category / seller URLs (paginated; offer URLs are always full detail) | | `maxItemsPerQuery` | integer | no | `100` | Max products per query/URL (1–6000; search/category capped by Allegro at ~6000, storefronts uncapped) | | `maxPagesPerQuery` | integer | no | β€” | Optional hard cap on pages per query/URL | | `minPrice` / `maxPrice` | integer | no | β€” | Price range filter in PLN (`price_from` / `price_to`; search & category URLs only) | | `condition` | select | no | `all` | `all`, `new` (nowe), `used` (uΕΌywane) | | `sortBy` | select | no | `relevance` | `relevance`, `price-asc`, `price-desc`, `newest` | | `scrapeProductDetails` | boolean | no | `false` | Visit each offer page for deep data (1 extra request/product) | | `includeRawData` | boolean | no | `false` | Attach raw Allegro payloads to detailed records (deep mode only) | | `barcodeQuickLookup` | boolean | no | `true` | Skip detail fetch for pure EAN/GTIN single-item queries and echo the barcode into `gtin` | | `geoCode` | select | no | `pl` | Proxy exit country (keep `pl` for allegro.pl pricing; also `de`, `cz`, `sk`, `hu`) | | `concurrency` | integer | no | `25` | Parallel requests (1–50; 50 for large/deep runs) | | `warmup` | boolean | no | `true` | Solve DataDome once per query in a patched browser, reuse the cookie for all pages (~1–2 s/page) | | `warmConcurrency` | integer | no | `3` | Parallel warm solves (1–6) | | `proxyConfiguration` | object | no | β€” | Apify Proxy groups (sticky `RESIDENTIAL` first + `UNBLOCKER` fallback recommended) or custom `proxyUrls` | | `scrapeDoApiKey` | string (secret) | no | β€” | Managed DataDome bypass via `api.scrape.do` (premium `super=true` routing) | #### Anti-bot / proxy setup (verified) Allegro sits behind **DataDome** β€” plain `fetch` returns HTTP 403. Fastest path: enable Proxy, keep **warmup on** and put a **sticky** group first (`"apifyProxyGroups": ["RESIDENTIAL", "UNBLOCKER"]`) β€” the actor solves DataDome once per query and reuses the cookie. For a pure-managed run set `"warmup": false` with the `UNBLOCKER` group. Alternatively supply a `scrapeDoApiKey` (premium, `super=true`) or custom Polish residential proxies. Without a working bypass the run fails loudly with `BLOCKED: Allegro returned HTTP 403 (DataDome bot wall)`. #### Cost & speed Platform compute (allocated memory Γ— wall-clock) plus proxy units. In **warmup mode** the proxy bill is tiny β€” one DataDome solve per query, pages at ~1–2 s. With UNBLOCKER each page is a separate pooled-browser render (~55–65 s, 25–50 concurrent). Keep `maxItemsPerQuery` tight (100 = 2 pages vs 6,000 = 100 pages). ##### Example input ```json { "searchQueries": ["laptop gaming", "iphone 15"], "minPrice": 500, "maxPrice": 5000, "condition": "new", "sortBy": "price-asc", "maxItemsPerQuery": 200, "scrapeProductDetails": true, "scrapeDoApiKey": "…" } ``` ### Build a Price-Monitoring Feed With the Apify API Every run pushes results to an Apify dataset you can download as JSON, CSV, XML or Excel, or stream via the **Apify REST API**. Integrate with your stack through: - **Apify API** β€” trigger runs, poll status, pull dataset items programmatically (`POST /v2/acts/{actorId}/runs`, `GET /v2/datasets/{datasetId}/items`). - **Schedules** β€” run daily/weekly for recurring **price monitoring** and **competitor tracking**; each run's dataset becomes a time-series slice. - **Webhooks** β€” notify your app the moment a run finishes. - **Zapier / Make** β€” via Apify's official Zapier and Make integrations, connect scraped Allegro data to Google Sheets, Slack, Airtable and hundreds of other apps without code. Recommended schedule: **daily** for price monitoring, **weekly** for market research and seller assortment snapshots. ### Related Allegro Scrapers and Alternative Data Sources - **[e-commerce/allegro-fast-product-scraper](https://apify.com/e-commerce/allegro-fast-product-scraper)** β€” the most-used Allegro actor on the store: quick listing-level data across 3 markets (pl/de/cz). - **[e-commerce/allegro-product-detail-scraper](https://apify.com/e-commerce/allegro-product-detail-scraper)** β€” dedicated deep product-detail page scraper (descriptions, parameters, images). - **[e-commerce/allegro-reviews-scraper](https://apify.com/e-commerce/allegro-reviews-scraper)** β€” collect product reviews from Allegro listings. - **[memo23/allegro-scraper](https://apify.com/memo23/allegro-scraper)** β€” similar keyword/category/seller coverage (compare per-result pricing). - **[liveclaude/allegro-ean-price-tracker](https://apify.com/liveclaude/allegro-ean-price-tracker)** β€” price tracking driven by EAN/GTIN lists. This actor differentiates on **price per full result row** ($0.0014/result, the lowest in the category) while bundling deep-mode fields (stock, GTIN, warranty, returns) that listing-only actors charge extra requests for. ### FAQ: Allegro Scraping Questions **Can I scrape Allegro without an API key?** Yes β€” this scraper needs no OAuth, no Allegro seller account and no API key. The official Allegro REST API is seller-scoped and OAuth-gated; it can't be used for general market research. The actor reads the JSON Allegro embeds in public pages (through a managed anti-bot bypass). **Is it legal to scrape Allegro.pl?** This actor extracts only publicly available product data β€” no login, no paywall bypass, no private or personal data. You are responsible for complying with Allegro's Terms of Service and applicable law; the actor is intended for legitimate price monitoring, market research and competitive analysis. See the disclaimer below. **How do I monitor competitor prices on Allegro / jak monitorowaΔ‡ ceny konkurencji na Allegro?** Run this actor on a daily schedule on your competitor's category or seller storefront URLs. `price` + `originalPrice` + `priceWithDelivery` give you the full picture; store each run's dataset to build a price history. This replaces paid tools like Allegro Analytics (subscription) for price-history monitoring. **Why are some fields (rating, GTIN, stock, condition) empty in listing mode?** Allegro only embeds part of the data in search results. Enable **Scrape full product details** to fill rating, reviews, stock, GTIN, warranty, return policy and the full description (one extra request per product). **How many products can I scrape per query?** ~60 products/page. Search and category views are capped by Allegro at 100 pages (~6,000 per query/URL) β€” slice a bigger category with `minPrice`/`maxPrice`. Seller storefronts have no 100-page cap. **Can I get stock and availability data?** Yes β€” in deep mode `detail.stock.available` returns the exact available quantity to the unit. **How do I look up a product by EAN/GTIN?** Set `searchQueries: [""]` with `maxItemsPerQuery: 1` and keep `barcodeQuickLookup: true` (default) β€” the barcode is echoed into `gtin` without an extra request, making large barcode runs dramatically cheaper and faster. **Is the scraped text in Polish?** Yes β€” titles, conditions, parameter names and descriptions are Allegro's original Polish. Prices are in PLN. **What are the alternatives to this scraper?** See the related-actors list above (fast-product-scraper, product-detail-scraper, reviews-scraper, seller-scraper and EAN price tracker) β€” plus any non-Apify API services you already evaluate. ### For AI Agents & LLM Apps **Purpose:** returns structured product data from Allegro.pl β€” one dataset row per offer, combining listing-level fields (price, seller, condition, popularity) and optionally deep offer-page fields (stock, GTIN, warranty, rating distribution, full description). **Minimal input:** ```json { "searchQueries": ["iphone 15"] } ``` **Variant inputs:** ```json { "startUrls": ["https://allegro.pl/uzytkownik/Kong"], "maxItemsPerQuery": 6000 } { "searchQueries": ["5907494722515"], "maxItemsPerQuery": 1 } ``` **Output fields:** `offerId`, `productId`, `url`, `title`, `brand`, `price`, `originalPrice`, `priceWithDelivery`, `condition`, `delivery`, `seller`, `sponsored`, `promoted`, `smart`, `productOffersCount`, `popularity`, `rating`, `parameters`, `images`, `categoryId`, `searchQuery`, `sourceUrl`, `scrapedAt`, and `detail` (deep mode: `stock`, `gtin`, `rating`, `returnPolicy`, `warranty`, `breadcrumbs`, `parameterGroups`, `description`, `images`, `raw`). **Behaviors an agent should know:** - Text and prices are **Polish / PLN**. `searchQuery`/`sourceUrl` tag which query/URL each row came from. - `searchQueries` and `startUrls` both run in the same crawl; rows are deduped by `offerId`. - `minPrice`, `maxPrice`, `condition` and `sortBy` apply **only to search and category URLs** β€” seller and offer URLs ignore them. - `detail` is populated **only** when `scrapeProductDetails: true` or the input is a direct offer URL; listing-level fields are always present. `includeRawData` requires deep mode. - `barcodeQuickLookup` only triggers for a **pure EAN/GTIN query with `maxItemsPerQuery: 1`** β€” for 8–14 digit barcodes this skips the per-offer fetch and echoes the barcode into `gtin`. Set `maxItemsPerQuery` > 1 for keyword searches. - If `maxItemsPerQuery` is left unset the default is 100 (β‰ˆ2 pages). Bare keyword queries without `scrapeProductDetails` are cheap; deep mode adds one billed request per product. - DataDome: enable Apify Proxy, keep `warmup: true` with a sticky group first (`RESIDENTIAL`) and `UNBLOCKER` as fallback, or provide `scrapeDoApiKey`. Without any bypass every request returns 403 and the run fails. - **Billing (pay-per-event):** $0.005 per run start + **$0.0014 per result** β€” budget roughly `0.005 + 0.0014 Γ— items`. ### SEO Keywords allegro scraper, allegro.pl scraper, scrape allegro products, allegro price monitoring, allegro price tracker, monitorowanie cen allegro, analiza konkurencji allegro, ceny konkurencji allegro, allegro api alternative, allegro product data, dane produktowe allegro, allegro sellers, sprzedawcy allegro, allegro gtin, ean lookup allegro, allegro stock, dostΔ™pnoΕ›Δ‡ allegro, allegro dropshipping, poland marketplace data, allegro price history, historia cen allegro, allegro oferty, allegro smart, badanie rynku allegro ### Legal & Compliance Disclaimer This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Allegro.pl or Allegro sp. z o.o.** It extracts only publicly available product information displayed on Allegro.pl β€” it does not log in, bypass paywalls, solve CAPTCHAs itself (it routes through managed anti-bot proxy services to retrieve public pages), or collect personal or private data. Users are responsible for their own compliance with Allegro's Terms of Service and applicable law, including the GDPR for any personal data contained in seller profiles. The data is intended for legitimate purposes such as price monitoring, market research and competitive analysis. ### Development ```bash npm install npm test # unit tests for the parsers npm run lint # syntax-check the sources ``` The parsers are tested against realistic fixtures in `test/fixtures/` (a listing page, an offer page, and a DataDome challenge page). # Actor input Schema ## `searchQueries` (type: `array`): Keywords to search on Allegro.pl. Each keyword runs its own paginated crawl, e.g. "laptop gaming", "iphone 15", "lego technic". ## `startUrls` (type: `array`): Direct Allegro URLs β€” offer pages (allegro.pl/oferta/…), search/category pages (allegro.pl/listing?string=… or allegro.pl/kategoria/…) or seller storefronts (allegro.pl/uzytkownik/…). Listing/category/seller URLs are paginated; offer URLs return a single product (always full detail). A `p=N` in the URL is respected and the crawl continues forward from that page β€” handy for splitting a huge storefront into page batches. Runs in addition to the search queries. ## `maxItemsPerQuery` (type: `integer`): Upper bound of products to extract per search query or per listing/category/seller URL. Allegro serves ~60 products per page. Search and category views are capped by Allegro at 100 pages (~6000 products per query); seller storefronts have no such cap and are followed to their real last page. ## `maxPagesPerQuery` (type: `integer`): Optional hard cap on the number of listing pages fetched per query/URL, independent of the item limit. Defaults to the number of pages needed to reach Max items per query (capped at 100 for search/category by Allegro). ## `minPrice` (type: `integer`): Only return offers priced at or above this value in PLN. Maps to Allegro's `price_from` filter (applied to search and category URLs). ## `maxPrice` (type: `integer`): Only return offers priced at or below this value in PLN. Maps to Allegro's `price_to` filter (applied to search and category URLs). ## `condition` (type: `string`): Filter by product condition (Allegro's "stan" filter). ## `sortBy` (type: `string`): Order of the search/category results. ## `scrapeProductDetails` (type: `boolean`): Visit each offer page for the deep dataset: full description, complete parameter table, rating + review count + score distribution, stock quantity, GTIN/EAN, warranty, return policy and full-resolution images. Costs one extra request per product (slower). Leave off for fast, rich listing-level data. ## `includeRawData` (type: `boolean`): Attach the raw Allegro offer payloads (price / seller / rating / parameters boxes) to each detailed record under `detail.raw`. Only used when "Scrape full product details" is on. For debugging / power users. ## `barcodeQuickLookup` (type: `boolean`): When a search query is a pure EAN/GTIN barcode (8–14 digits) and "Max items per query" is 1, skip the extra per-offer fetch and echo the searched barcode into the record's `gtin` field. The listing data still gives price, seller, rating, images and parameters β€” making big barcode runs dramatically faster and cheaper. Turn OFF if you need descriptions, stock, warranty or return policy on barcode lookups. Only affects pure-EAN single-item queries; keyword and multi-item searches always fetch full details when deep mode is on. ## `geoCode` (type: `string`): Country the proxy request exits from (Allegro localises prices and availability by IP). Default "pl" (Poland) is correct for allegro.pl. ## `concurrency` (type: `integer`): How many products/pages to fetch in parallel (1–50). UNBLOCKER re-renders each page in a real browser (~55–65 s), so parallelism is the main speed lever and it also cuts compute cost (cost β‰ˆ allocated memory Γ— wall-clock). Default 25; use 50 for large/deep runs. ## `warmup` (type: `boolean`): Experimental speed boost: for each query, a patchright (engine-level undetectable) Chromium solves DataDome ONCE on a sticky Apify proxy session (same IP), then all pages of the query are fetched in parallel via curl-impersonate with the matching cookie β€” ~1–2 s/page instead of a fresh ~55–65 s UNBLOCKER render per page, no per-page solver fees. Put a STICKY group FIRST in `apifyProxyGroups` (e.g. \["RESIDENTIAL"]); if you also list UNBLOCKER, any page whose warm fetch fails automatically falls back to UNBLOCKER, so the run still completes reliably (note: pooled residential IPs are a lottery β€” some are pre-flagged, so solving may take a few attempts). If solving fails for every attempted IP, the whole query falls back to the per-page managed path. Recommended: `"apifyProxyGroups": ["RESIDENTIAL", "UNBLOCKER"]` for speed + reliability. ## `warmConcurrency` (type: `integer`): How many patched browsers may solve DataDome in parallel (1-6). Each browser costs ~300-500MB RAM; the 2-core container CPU-thrashes past ~3, slowing solves. Keep 3 unless the container has more cores. Many queries = many solves (DataDome re-challenges each new query string), so the efficient shape is FEW queries Γ— DEEP pagination (one solve serves ~5+ pages at ~5 items/s). ## `proxyConfiguration` (type: `object`): Select proxies used by the scraper. You can list MULTIPLE groups (first one wins for routing): - Warmup speed (recommended first): a STICKY group like RESIDENTIAL, or leave the default AUTO/datacenter β€” the actor solves DataDome once per query in a patched real browser and reuses the cookie on the same IP for every page. - UNBLOCKER (reliable fallback): list it after the sticky group; pages the warm path fails on are re-fetched through UNBLOCKER so runs always complete. For a pure-UNBLOCKER run (no warmup), set just \["UNBLOCKER"] and `warmup: false`. - Alternatively provide a scrape.do API key below (managed bypass, needs premium `super=true` routing). ## `scrapeDoApiKey` (type: `string`): Optional scrape.do managed-proxy API key. When set, every request is routed through `https://api.scrape.do?url=…&geoCode=pl&super=true&render=false&sessionId=…` (the official Allegro integration combo), which routes through Polish residential/mobile IPs and clears the DataDome challenge. Requires a scrape.do account with premium (super) routing enabled. ## Actor input object example ```json { "searchQueries": [ "laptop gaming", "iphone 15" ], "startUrls": [ { "url": "https://allegro.pl/listing?string=iphone+15" } ], "maxItemsPerQuery": 100, "condition": "all", "sortBy": "relevance", "scrapeProductDetails": false, "includeRawData": false, "barcodeQuickLookup": true, "geoCode": "pl", "concurrency": 25, "warmup": true, "warmConcurrency": 3, "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `results` (type: `string`): Products scraped from Allegro.pl β€” one row per offer. See the dataset schema for the full field list. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "searchQueries": [ "laptop gaming" ], "startUrls": [ { "url": "https://allegro.pl/listing?string=iphone+15" } ], "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("ahmed_jasarevic/allegro-scraper").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "searchQueries": ["laptop gaming"], "startUrls": [{ "url": "https://allegro.pl/listing?string=iphone+15" }], "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("ahmed_jasarevic/allegro-scraper").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 '{ "searchQueries": [ "laptop gaming" ], "startUrls": [ { "url": "https://allegro.pl/listing?string=iphone+15" } ], "proxyConfiguration": { "useApifyProxy": false } }' | apify call ahmed_jasarevic/allegro-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/allegro-scraper" } } } ``` 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 ` 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/o5sHa8WctGdb6IUOm/builds/mJcmCa1Q7cgqGJq1h/openapi.json