# Allegro.pl Product Scraper. Prices, Sellers, Stock & Specs (`karamelo/allegro-pl-scraper`) Actor

Scrape Allegro.pl products, prices, sellers, stock, ratings and specs by keyword, category, seller or offer URL. Fast & Cost-efficient.

- **URL**: https://apify.com/karamelo/allegro-pl-scraper.md
- **Developed by:** [karamelo](https://apify.com/karamelo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 product scrapeds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Allegro.pl is the undisputed leader in Central and Eastern European e-commerce, hosting tens of millions of active listings across consumer electronics, fashion, home goods, automotive parts, and groceries. The **Allegro.pl Scraper** provides a high-performance, cost-effective automation designed to extract structured product intelligence from Poland's premier marketplace without the heavy overhead of browser-based automation.

Whether you need to monitor competitor prices across hundreds of product categories, audit seller assortment depth, evaluate historical sales velocity, verify manufacturer part numbers and GTIN barcodes, or integrate real-time marketplace feeds into internal business intelligence pipelines, this Actor delivers reliable and comprehensive market data directly into your workflows.

***

### What does Allegro.pl Scraper do?

The Allegro.pl Scraper automates the discovery, extraction, and normalization of product offers from Allegro.pl. It supports flexible entry points including keyword searches, full category structures, complete merchant storefronts, and direct offer pages.

#### Core capabilities

- **Keyword search crawling**: Execute multiple search queries simultaneously, walking through paginated listing results and capturing every product card with its core commercial attributes.
- **Category exploration**: Traverse category landing pages to map entire product verticals, identify top-selling items, and analyze price distributions across subcategories.
- **Merchant storefront auditing**: Scrape all active listings belonging to a specific seller profile, enabling brand monitoring, competitor stock audits, and authorized reseller verification.
- **Deep specification extraction**: With deep mode enabled, the scraper visits individual offer pages to extract exhaustive technical parameter tables, product descriptions, stock quantities, warranty durations, return terms, and consumer review score distributions.
- **High-speed barcode lookups**: Perform ultra-fast single-item GTIN/EAN searches that bypass secondary detail requests when only listing-level price and merchant data are required.
- **Commercial signals & sales velocity**: Extract unique demand indicators including recent buyer counts, Smart! delivery badges, sponsored flags, and multi-seller catalog offer counts.

***

### Why use Allegro.pl Scraper?

Modern e-commerce intelligence demands speed, accuracy, and predictability. Traditional scraping solutions often rely on resource-intensive headless browser engines that consume large amounts of memory, suffer from slow rendering cycles, and drive up infrastructure expenses.

1. **Lightweight architecture**: Designed for maximum performance and cost efficiency, this Actor extracts structured data directly from marketplace responses, running smoothly at a fraction of the compute and memory requirements of browser-driven tools.
2. **Comprehensive data fidelity**: Instead of guessing selectors from volatile visual layouts, the scraper extracts clean structured records covering current prices, original pre-discount prices, delivery costs, merchant ratings, and complete product parameters.
3. **Dual operating modes**: Use fast listing mode for rapid price benchmarking across thousands of items per minute, or switch to deep mode when you need granular product specifications, full descriptions, warranty terms, and stock quantities.
4. **Resilient pagination**: Built-in pagination handling automatically respects query limits, tracks page depths, and deduplicates offers by unique marketplace identifiers.
5. **Ready-to-consume outputs**: Data is automatically formatted into clean JSON datasets ready for immediate export into CSV, Excel, Google Sheets, databases, or downstream AI pipelines.

***

### Who is Allegro.pl Scraper for?

This Actor is engineered to support a diverse range of data-driven business operations and analytical disciplines:

- **E-Commerce merchants & brand managers**: Monitor competitor pricing in real time, ensure Minimum Advertised Price (MAP) compliance across unauthorized sellers, and identify pricing opportunities during seasonal promotional campaigns.
- **Market analysts & category managers**: Map product assortment breadth across leading categories, discover trending items through sales velocity metrics, and benchmark competitive product catalogs.
- **Procurement & sourcing teams**: Locate trusted suppliers by filtering for verified business accounts with high positive feedback percentages and verified SuperSeller credentials.
- **Catalog & price comparison engines**: Ingest fresh, structured offer listings and GTIN barcodes to power automated price comparison platforms and consumer shopping portals.
- **Data scientists & AI application builders**: Enrich machine learning models and Retrieval-Augmented Generation (RAG) agents with structured European retail data and localized commercial signals.

***

### What data can you extract?

The Actor captures a comprehensive set of product, pricing, merchant, and operational attributes.

#### Listing-level data (Fast mode)

Every product row returned from search, category, or storefront pages includes:

- **Offer identity**: Unique offer identifier, catalog product identifier, and permanent offer URL.
- **Commercial pricing**: Current offer price, currency (PLN), pre-discount price when on sale, and total cost inclusive of lowest delivery.
- **Product overview**: Listing title, detected brand or manufacturer, condition (e.g., Nowy, Używany), and main product image URL.
- **Delivery options**: Delivery fee, free shipping indicators, free return eligibility, and delivery speed labels.
- **Seller reputation**: Merchant identifier, merchant login username, business seller flag, SuperSeller status badge, and positive feedback percentage.
- **Demand & advertising flags**: Sponsored listing indicator, promoted placement flag, Allegro Smart! delivery eligibility, and recent buyer counts.
- **Key specifications**: Primary technical parameters such as manufacturer code, model, capacity, and package condition.

#### Deep offer details (Deep mode)

When **Scrape full product details** is enabled, each record is enriched with:

- **Full product description**: Complete descriptive text from the seller with structural sections and embedded image URLs.
- **Exhaustive parameter tables**: Grouped technical specifications categorized by functional attributes (e.g., technical parameters, dimensions, energy ratings).
- **Consumer reviews & ratings**: Average star rating, total rating count, written review count, and percentage distribution across score brackets (1 to 5 stars).
- **Inventory & stock depth**: Available unit stock quantity and purchase limits.
- **Identifiers**: Confirmed manufacturer GTIN / EAN barcode numbers.
- **Post-purchase terms**: Commercial warranty period, warranty provider type, and consumer withdrawal/return policy timeframes.
- **Category hierarchy**: Full breadcrumb path from marketplace root to leaf category.

***

### Input configuration & parameters

The Actor accepts intuitive configuration options through the Apify Console interface or raw JSON input.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | Array of strings | `["laptop gaming"]` | List of search keywords to crawl. Each query executes an independent paginated search. |
| `startUrls` | Array of objects/strings | `[]` | Direct Allegro URLs including search listings, category pages, seller profiles, or individual offer URLs. |
| `maxItemsPerQuery` | Integer | `100` | Upper bound of products to extract per search query or per listing URL. |
| `minPrice` | Integer | `null` | Optional lower bound price filter in Polish złoty (PLN). |
| `maxPrice` | Integer | `null` | Optional upper bound price filter in Polish złoty (PLN). |
| `condition` | String | `"all"` | Filter by condition: `"all"` (any), `"new"` (Nowe), or `"used"` (Używane). |
| `sortBy` | String | `"relevance"` | Sort order: `"relevance"`, `"price-asc"`, `"price-desc"`, or `"newest"`. |
| `scrapeProductDetails` | Boolean | `false` | Enable deep mode to visit individual offer pages for descriptions, full specs, stock, and reviews. |
| `includeRawData` | Boolean | `false` | Attach raw internal data objects to deep records for advanced debugging. |
| `barcodeQuickLookup` | Boolean | `true` | Skip detail page fetch when search query is an 8–14 digit EAN barcode and max items is 1. |
| `geoCode` | String | `"pl"` | Proxy exit country code. Default is `"pl"` (Poland) to ensure localized pricing. |
| `concurrency` | Integer | `10` | Number of parallel request threads (1 to 50). Default is 10. |
| `proxyConfiguration` | Object | `{"useApifyProxy": true}` | Apify Proxy settings. Residential proxy pool is recommended for reliable access. |

***

### Example inputs & practical walkthroughs

#### Example 1: Rapid competitive price audit (Fast listing mode)

Extract the first 50 offers for gaming laptops, filtered to brand-new condition and sorted by ascending price:

```json
{
  "searchQueries": ["laptop gaming"],
  "maxItemsPerQuery": 50,
  "condition": "new",
  "sortBy": "price-asc",
  "minPrice": 2500,
  "maxPrice": 8000,
  "scrapeProductDetails": false
}
```

#### Example 2: Deep seller inventory extraction

Extract complete product catalogs, stock quantities, and descriptions from a specific merchant storefront:

```json
{
  "startUrls": [
    { "url": "https://allegro.pl/uzytkownik/Swiatbaterii" }
  ],
  "maxItemsPerQuery": 100,
  "scrapeProductDetails": true,
  "concurrency": 15
}
```

#### Example 3: Bulk GTIN / EAN barcode verification

Look up product availability and pricing for a specific barcode with rapid lookup enabled:

```json
{
  "searchQueries": ["5904326374249"],
  "maxItemsPerQuery": 1,
  "barcodeQuickLookup": true,
  "scrapeProductDetails": false
}
```

***

### Output data structure & sample records

The output is written incrementally to the default Apify Dataset. Below is an illustrative example of an extracted product record in deep mode:

```json
{
  "offerId": "18680248718",
  "productId": "4b1d1ed0-07d6-402b-8d41-294a7eb532c1",
  "gtin": "5904326374249",
  "url": "https://allegro.pl/oferta/18680248718",
  "title": "Laptop ASUS TUF Gaming F16 Core 5 16GB 512GB RTX3050",
  "brand": "ASUS",
  "price": {
    "amount": 3350.00,
    "currency": "PLN"
  },
  "originalPrice": {
    "amount": 3799.00,
    "currency": "PLN"
  },
  "priceWithDelivery": {
    "amount": 3350.00,
    "currency": "PLN"
  },
  "condition": "Nowy",
  "delivery": {
    "free": true,
    "freeReturn": true,
    "lowestCost": {
      "amount": 0.00,
      "currency": "PLN"
    },
    "label": "Darmowa dostawa"
  },
  "seller": {
    "id": "160080",
    "login": "OfficialStore",
    "name": "OfficialStore Sp. z o.o.",
    "company": true,
    "superSeller": true,
    "positiveFeedbackPercent": 99.5,
    "url": "https://allegro.pl/uzytkownik/OfficialStore"
  },
  "sponsored": false,
  "promoted": false,
  "smart": true,
  "productOffersCount": 4,
  "popularity": {
    "label": "18 osób kupiło ostatnio",
    "buyersQuantity": 18
  },
  "rating": {
    "value": 4.88,
    "count": 42
  },
  "parameters": [
    { "name": "Pamięć RAM", "value": "16 GB" },
    { "name": "Pojemność dysku", "value": "512 GB" },
    { "name": "Karta graficzna", "value": "NVIDIA GeForce RTX 3050" }
  ],
  "images": [
    "https://a.allegroimg.com/original/example-image-1.jpg",
    "https://a.allegroimg.com/original/example-image-2.jpg"
  ],
  "thumbnail": "https://a.allegroimg.com/s180/example-thumbnail.jpg",
  "categoryId": "491",
  "searchQuery": "laptop gaming",
  "sourceUrl": "https://allegro.pl/listing?string=laptop%20gaming",
  "scrapedAt": "2026-09-15T12:40:00.000Z",
  "detail": {
    "name": "Laptop ASUS TUF Gaming F16 Core 5 16GB 512GB RTX3050",
    "condition": "Nowy",
    "description": "Wysokiej wydajności laptop gamingowy wyposażony w procesor Intel Core 5 oraz dedykowaną kartę graficzną RTX 3050.",
    "parameters": [
      { "name": "Model procesora", "value": "Intel Core 5" },
      { "name": "Taktowanie bazowe", "value": "2.8 GHz" }
    ],
    "parameterGroups": [
      {
        "group": "Procesor",
        "parameters": [
          { "name": "Model procesora", "value": "Intel Core 5" },
          { "name": "Liczba rdzeni", "value": "8" }
        ]
      }
    ],
    "stock": {
      "available": 25,
      "label": "25 sztuk",
      "unit": "UNIT"
    },
    "warranty": {
      "period": "24 miesiące",
      "type": "producenta/dystrybutora",
      "label": "Gwarancja producenta przez 24 miesiące"
    },
    "returnPolicy": {
      "withdrawalPeriod": "14 dni",
      "costLabel": "Darmowy zwrot Allegro Smart!"
    },
    "breadcrumbs": ["Allegro", "Elektronika", "Komputery", "Laptopy"]
  }
}
```

***

### Integrations & Export options

Once extracted, your Allegro market data can be seamlessly connected to analytical destinations and external storage systems.

#### Formats & direct downloads

From the Apify Console or API, you can export your dataset in multiple formats:

- **JSON / JSONL**: Ideal for software integrations, cloud databases, and AI model ingestion.
- **CSV / TSV**: Standard tabular structure for data warehouses, pandas DataFrames, and statistical software.
- **Excel (XLSX)**: Formatted spreadsheets suitable for executive summaries and manual reviews.
- **HTML / XML**: Web-ready views and syndication feeds.

#### Automation & cloud integrations

- **Scheduled runs**: Set up recurring schedules (e.g., daily at 06:00 UTC) to monitor price movements and inventory changes over time.
- **Webhooks**: Configure real-time webhook alerts to trigger an endpoint when an Actor run finishes, enabling immediate downstream processing.
- **Cloud storage & databases**: Stream results directly to Amazon S3, Google Cloud Storage, BigQuery, PostgreSQL, or Snowflake using Apify's turnkey integrations.
- **Business tools**: Connect scraped datasets directly to Zapier, Make, Airtable, or Google Sheets to trigger alerts on competitor price cuts.

***

### Performance, batching & pagination limits

Understanding marketplace pagination and batching structures ensures efficient crawl orchestration:

- **Listing batch sizes**: Allegro serves approximately 60 product offers per listing page.
- **Search & category page limits**: The marketplace caps search and category pagination at 100 pages (approximately 6,000 products per specific query). To harvest broader catalogs exceeding this cap, subdivide your crawls into narrower price brackets using `minPrice` and `maxPrice`.
- **Merchant storefronts**: Seller storefronts are followed to their true last page without an arbitrary 100-page limit.
- **Resuming & splitting runs**: You can include a `p=N` parameter in your start URLs (e.g., `https://allegro.pl/uzytkownik/seller_name?p=51`) to resume crawls or partition massive seller catalogs into concurrent batches.
- **Concurrency recommendations**: For standard listing extraction, concurrency between 5 and 15 provides optimal throughput. For deep detail extraction runs, settings between 15 and 30 maximize speed while maintaining stable connection pools.

***

### Pricing & resource consumption

This Actor is engineered for exceptional cost efficiency:

- **Resource footprint**: Engineered for high-speed lightweight operation without the overhead of heavy browser engines. The Actor runs comfortably with 512 MB to 1024 MB of memory.
- **Proxy usage**: Residential proxies configured with exit nodes in Poland (`geoCode: "pl"`) ensure consistent localized pricing and currency data.
- **Execution speed**: In listing mode, the Actor can extract up to 1,000 product rows in under two minutes under standard network conditions.

***

### Troubleshooting & Common questions (FAQ)

#### Frequently Asked Questions

**Do I need an Allegro account or API credentials to use this scraper?**\
No. The scraper accesses public product listings and offer pages without requiring user login credentials or API keys from the marketplace.

**Why are prices and text in Polish?**\
Allegro.pl is localized for the Polish market. Product titles, parameters, descriptions, and seller notes are extracted in their original Polish text, and prices are quoted in Polish złoty (PLN).

**When should I use Fast Listing mode versus Deep mode?**\
Use Fast Listing mode (`scrapeProductDetails: false`) when your primary objective is tracking prices, seller identities, stock availability flags, and basic parameters across large product catalogs. Enable Deep mode (`scrapeProductDetails: true`) when you require full descriptions, warranty documents, detailed specification matrices, exact remaining stock quantities, or review distributions.

**How can I scrape more than 6,000 products for a single query?**\
Because Allegro limits search results to 100 pages, slice wide product categories into logical subsets using `minPrice` and `maxPrice` intervals (e.g., 0–500 PLN, 501–1000 PLN, 1001–2000 PLN).

**What happens if a product runs out of stock or is ended?**\
Ended or inactive offers that do not appear in active search listings are naturally excluded. When querying direct offer URLs that have expired, the scraper captures available archive details or reports the inactive state cleanly.

**Can I run the scraper programmatically via the Apify API?**\
Yes. You can trigger runs and retrieve datasets using the official Apify JavaScript Client (`apify-client`), Python Client, or direct REST API calls.

***

### Compliance & Responsible data usage

The Allegro.pl Scraper is intended for ethical, authorized data acquisition practices including market research, competitive price intelligence, and brand monitoring.

- **Public data only**: The Actor extracts only publicly accessible commercial listings. It does not access private account portals, transaction histories, or confidential customer details.
- **Respect platform infrastructure**: Avoid setting excessively high concurrency levels that could place disproportionate load on marketplace servers. Concurrency between 10 and 20 provides reliable performance while maintaining responsible traffic rates.
- **Regulatory considerations**: When storing or processing extracted data, ensure compliance with applicable data privacy regulations, including GDPR and local intellectual property laws.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on Allegro.pl. Each keyword runs its own paginated crawl. Example: 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. A p=N parameter in the URL is respected.

## `maxItemsPerQuery` (type: `integer`):

Upper bound of products to extract per search query or per listing URL. Allegro serves ~60 products/page and caps search/category views at 100 pages (~6000 max per query); seller storefronts have no such cap and are followed to their real last page.

## `minPrice` (type: `integer`):

Only return offers priced at or above this value, in Polish zloty (PLN). Maps to Allegro price\_from filter.

## `maxPrice` (type: `integer`):

Only return offers priced at or below this value, in Polish zloty (PLN). Maps to Allegro price\_to filter.

## `condition` (type: `string`):

Filter by product condition.

## `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, stock quantity, GTIN/EAN, warranty, return policy, and full seller reputation.

## `includeRawData` (type: `boolean`):

Attach the raw Allegro offer object to each detailed record. Only applies when Scrape full product details is on.

## `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 product detail page and echo the searched barcode into the record gtin field. The listing data still returns price, seller, rating, images and parameters.

## `geoCode` (type: `string`):

Country the request exits from (Allegro localises prices/availability by IP). Default pl (Poland) is correct for allegro.pl.

## `concurrency` (type: `integer`):

How many products/pages to fetch in parallel (1–50). Default 10.

## `proxyConfiguration` (type: `object`):

Apify Proxy configuration. By default uses residential proxies in Poland.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop gaming"
  ],
  "startUrls": [],
  "maxItemsPerQuery": 20,
  "condition": "all",
  "sortBy": "relevance",
  "scrapeProductDetails": false,
  "includeRawData": false,
  "barcodeQuickLookup": true,
  "geoCode": "pl",
  "concurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Output dataset items containing scraped Allegro products.

# 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 = {
    "searchQueries": [
        "laptop gaming"
    ],
    "startUrls": [],
    "maxItemsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("karamelo/allegro-pl-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["laptop gaming"],
    "startUrls": [],
    "maxItemsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("karamelo/allegro-pl-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": [],
  "maxItemsPerQuery": 20
}' |
apify call karamelo/allegro-pl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,karamelo/allegro-pl-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 <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/ELY2iV1hiK2NqEM6i/builds/auexSgUVbYgDy1tDF/openapi.json