# Allegro Reviews Scraper (`automation-lab/allegro-reviews-scraper`) Actor

Extract public Allegro buyer opinions with ratings, text, pros and cons, images, helpfulness, dates, translations, seller, and product context.

- **URL**: https://apify.com/automation-lab/allegro-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Reviews Scraper

Extract public **Allegro reviews** as structured records for product reputation monitoring, quality research, and recurring marketplace analysis.

The Actor reads Allegro's public product-opinion data and returns one dataset item per buyer opinion. Each item can include the rating, original text, pros and cons, buyer images, date, helpfulness, language, translation, seller, product identifier, and variant details.

It uses a lightweight public JSON route. No Allegro login, API key, browser, or proxy is required.

### What does Allegro Reviews Scraper do?

Allegro Reviews Scraper turns public buyer opinions into analysis-ready JSON, CSV, or Excel data.

Use it to:

- collect individual opinions instead of only aggregate review counts;
- compare recurring snapshots of product feedback;
- find frequently mentioned strengths and defects;
- filter a product's opinions by rating;
- isolate reviews with buyer-uploaded images;
- retain original Polish text and Allegro-provided translations;
- send review records to a warehouse, spreadsheet, or AI workflow.

The Actor accepts canonical Allegro product URLs that contain a product UUID. It also accepts UUIDs directly for scheduled and bulk workflows.

### Who is this Actor for?

**Brand and marketplace teams** can monitor feedback about products they sell or compete with.

**Product researchers** can group pros, cons, ratings, and review text to identify recurring quality signals.

**Customer-experience teams** can track low-rating opinions and useful-vote counts.

**Data engineers** can schedule stable product UUIDs and load normalized records into a warehouse.

**AI and automation builders** can provide fresh public opinions to sentiment, summarization, and classification workflows.

Choose [Allegro.pl Product Scraper](https://apify.com/automation-lab/allegro-scraper) when you need product listing cards, prices, sellers, or aggregate rating counts rather than individual buyer opinions.

### What Allegro review data can you extract?

| Field | Meaning |
| --- | --- |
| `reviewId` | Stable Allegro opinion identifier |
| `productId` | Product UUID used for the request |
| `productUrl` | Canonical input URL, when supplied |
| `productTitle` | Title derived from the canonical URL slug |
| `authorName` | Public masked reviewer name |
| `opinion` | Original opinion text |
| `rating` | Numeric star rating |
| `pros`, `cons` | Buyer-provided advantages and disadvantages |
| `images` | Public buyer-uploaded image URLs |
| `createdAt` | Opinion creation timestamp |
| `helpfulVotes` | Helpful vote count |
| `unhelpfulVotes` | Not-helpful vote count |
| `helpfulPercentage` | Helpful vote percentage when available |
| `sourceLanguage` | Locale of the original opinion |
| `translatedOpinion` | Allegro-provided translated text when available |
| `translatedPros`, `translatedCons` | Translated advantages and disadvantages |
| `sellerLogin` | Public seller login associated with the opinion |
| `flags` | Allegro opinion labels such as `BEST` |
| `variantParameters` | Reviewed size, color, or other variant data |
| `sourceType` | Opinion source type reported by Allegro |
| `scrapedAt` | Extraction timestamp |

Fields that Allegro does not provide for an opinion are returned as `null` or an empty array.

### How to get started

1. Open the Actor in Apify Console.
2. Add a canonical Allegro `/produkt/` URL, or enter a product UUID.
3. Set the maximum number of matching reviews per product.
4. Optionally choose a rating range or require buyer images.
5. Click **Start**.
6. Open the **Dataset** tab.
7. Export the records to JSON, CSV, Excel, XML, or another supported format.

The prefilled canonical product URL is a small real example suitable for a first run.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | none | Canonical Allegro `/produkt/` URLs containing a UUID |
| `productIds` | string array | none | Allegro product UUIDs for direct or bulk use |
| `maxReviewsPerProduct` | integer | `100` | Maximum matching records saved for each product, from 1 to 1,000 |
| `minRating` | number | `1` | Minimum accepted star rating |
| `maxRating` | number | `5` | Maximum accepted star rating |
| `withImagesOnly` | boolean | `false` | Save only opinions that include public images |

Provide at least one `startUrls` entry or one `productIds` entry.

Duplicate product UUIDs are processed once. The limit is applied separately to each product after filters.

#### Canonical product URL input

```json
{
  "startUrls": [
    {
      "url": "https://allegro.pl/produkt/korki-adidas-f50-elite-ag-buty-pilkarskie-lanki-na-sztuczna-trawe-orlik-4549a95f-0be1-41b3-954f-015bea7131b3?offerId=18016530911"
    }
  ],
  "maxReviewsPerProduct": 10
}
```

#### Product UUID and photo filter input

```json
{
  "productIds": [
    "8e2abfdd-4b19-4384-beee-7d9c5f8dadd6"
  ],
  "maxReviewsPerProduct": 25,
  "withImagesOnly": true
}
```

#### Low-rating analysis input

```json
{
  "productIds": [
    "8e2abfdd-4b19-4384-beee-7d9c5f8dadd6"
  ],
  "maxReviewsPerProduct": 100,
  "minRating": 1,
  "maxRating": 3
}
```

### What does the output look like?

The default dataset contains one item per accepted opinion.

This representative record follows the current live source shape. The example identifier and public names are anonymized:

```json
{
  "reviewId": "69abc12310b2326b038a4000",
  "productId": "12345678-abcd-4000-9000-123456789abc",
  "productUrl": "https://allegro.pl/produkt/sample-product-12345678-abcd-4000-9000-123456789abc",
  "productTitle": "Sample product",
  "authorName": "A...7",
  "opinion": "The product works as expected and arrived safely.",
  "rating": 5,
  "ratingLabel": "5",
  "pros": "Easy to use, solid build",
  "cons": "Packaging could be smaller",
  "images": [
    "https://a.allegroimg.com/original/example-image"
  ],
  "createdAt": "2026-01-15T12:00:00.000Z",
  "helpfulVotes": 8,
  "unhelpfulVotes": 1,
  "helpfulPercentage": 89,
  "sourceLanguage": "pl-PL",
  "translatedOpinion": "The product works as expected and arrived safely.",
  "translatedPros": "Easy to use, solid build",
  "translatedCons": "Packaging could be smaller",
  "sellerLogin": "example_store",
  "flags": ["BEST"],
  "variantParameters": [
    { "name": "Size", "value": "Medium" }
  ],
  "sourceType": "ALLEGRO",
  "scrapedAt": "2026-01-20T10:30:00.000Z"
}
```

The dataset schema includes a table view for product, rating, text, pros, cons, date, helpful votes, images, seller, and source URL.

### How much does it cost to extract Allegro reviews?

The Actor uses pay-per-event pricing:

- one `start` event costs **$0.0005 per run**;
- one `review` event is charged only for each opinion saved to the dataset;
- filtered, duplicate, empty, and failed records are not charged as reviews.

| Apify tier | Price per saved review |
| --- | ---: |
| Free | $0.0015640 |
| Bronze | $0.0013600 |
| Silver | $0.0010608 |
| Gold | $0.0008160 |
| Platinum | $0.0005440 |
| Diamond | $0.0003808 |

Bronze cost examples use this exact formula:

| Saved reviews | Charge calculation |
| ---: | --- |
| 1 | one start event + 1 × the Bronze review event |
| 100 | one start event + 100 × the Bronze review event |
| 1,000 | one start event + 1,000 × the Bronze review event |

This avoids hiding rounding in a quoted total. Actual saved volume depends on the number of public opinions and your filters. Check the Actor's Pricing tab for the tier assigned to your Apify plan.

### Product reputation monitoring workflow

A recurring workflow can use stable product UUIDs without loading protected product pages:

1. Store the UUIDs for the products you follow.
2. Schedule this Actor daily or weekly.
3. Set a useful per-product review limit.
4. Save `reviewId` as the deduplication key in your database.
5. Compare newly observed IDs with the previous run.
6. Alert on low ratings, repeated cons, or sudden review volume.
7. Build trend summaries by product, seller, language, or variant.

The Actor returns current public opinions. It does not maintain historical state or send alerts by itself.

### Image review and quality-analysis workflow

Set `withImagesOnly` to `true` to collect opinions with public buyer media.

Possible downstream steps include:

- image quality inspection;
- packaging-damage classification;
- product-color comparison;
- evidence review for recurring defects;
- joining text sentiment with visual signals.

Image URLs point to Allegro's public media delivery. Availability can change after extraction.

### API usage with cURL

Replace `YOUR_API_TOKEN` with an Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~allegro-reviews-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productIds": ["8e2abfdd-4b19-4384-beee-7d9c5f8dadd6"],
    "maxReviewsPerProduct": 20,
    "withImagesOnly": true
  }'
```

To wait for completion and receive dataset items directly, use the synchronous dataset-items endpoint documented by Apify.

### API usage with JavaScript

Install the official client:

```bash
npm install apify-client
```

Run the Actor and retrieve its default dataset:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/allegro-reviews-scraper').call({
  productIds: ['8e2abfdd-4b19-4384-beee-7d9c5f8dadd6'],
  maxReviewsPerProduct: 20,
  minRating: 1,
  maxRating: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Keep API tokens in environment variables or a secret manager.

### API usage with Python

Install the official client:

```bash
pip install apify-client
```

Then call the Actor:

```python
import os
from apify_client import ApifyClient

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

run = client.actor('automation-lab/allegro-reviews-scraper').call(run_input={
    'productIds': ['8e2abfdd-4b19-4384-beee-7d9c5f8dadd6'],
    'maxReviewsPerProduct': 20,
    'withImagesOnly': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Use `reviewId` plus `productId` as a practical downstream deduplication key.

### Use Allegro Reviews Scraper with MCP and AI agents

Add the Actor to Claude Code through the Apify MCP server:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/allegro-reviews-scraper"
```

#### Claude Desktop setup

Add this server object to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/allegro-reviews-scraper"
    }
  }
}
```

#### Cursor setup

Add the same `apify` server object to Cursor's MCP settings. Use the remote HTTP URL shown above and complete Apify OAuth when prompted.

#### VS Code setup

Add the same remote server URL to your VS Code MCP configuration, then enable the `automation-lab/allegro-reviews-scraper` tool for your agent session.

Example prompts:

- “Collect up to 50 opinions for these Allegro product UUIDs and summarize the most common cons.”
- “Extract only Allegro reviews with buyer images and group them by rating.”
- “Compare the new review IDs with yesterday's dataset and list newly observed low ratings.”

AI-generated analysis should retain links or identifiers back to the underlying source records.

### Tips for reliable runs

- Prefer direct product UUIDs in scheduled workflows.
- Use canonical `/produkt/` URLs when you want `productUrl` and a title derived from its slug.
- Start with a small limit while testing a new product.
- Remember that filters are applied before the per-product saved limit.
- Use `withImagesOnly` only when image-bearing opinions are required.
- Expect `translation` fields to be null when Allegro does not provide a translation.
- Keep the stable `reviewId`; opinion ordering can change.
- No Apify Proxy configuration is necessary for the public JSON route.

Transient timeouts, rate limits, and server errors are retried with a bounded policy. Invalid input and unexpected response shapes fail the run instead of silently producing misleading empty data.

### Limitations

- Canonical URLs must contain an Allegro product UUID.
- Offer-only `/oferta/` and localized `/nabidka/` URLs do not expose that UUID and are rejected.
- You can instead copy the UUID from a canonical `/produkt/` URL into `productIds`.
- Product titles are derived from URL slugs; UUID-only input returns `productTitle: null`.
- The public opinion endpoint can return zero records for a valid product with no visible opinions.
- Allegro decides which translations, seller details, flags, and variant fields are present.
- The Actor does not translate text itself.
- The Actor does not scrape private buyer data, authenticated pages, or seller-account information.
- Maximum accepted output is 1,000 matching reviews per product per run.
- Source behavior and public response fields can change over time.

### Troubleshooting

#### Why was my product URL rejected?

Use a canonical URL containing a UUID, such as:

```text
https://allegro.pl/produkt/product-name-12345678-abcd-4000-9000-123456789abc
```

A URL shaped like `/oferta/name-1234567890` or `/nabidka/name-1234567890` contains an offer ID, not the required product UUID.

#### Why did a successful run return no rows?

The product may have no public opinions, or no opinions may match your rating and image filters. Try ratings 1–5 with `withImagesOnly: false`.

#### Why is the product title null?

Direct UUID input has no title text. Supply a canonical `/produkt/` URL if you need the URL-derived product title.

#### Why are translated fields null?

Translations are included only when Allegro supplies them. The original `opinion`, `pros`, and `cons` remain available.

#### Does the Actor need a Polish residential proxy?

No. The implementation uses a public structured opinion endpoint and does not fetch Allegro's protected product HTML.

### Responsible use and legality

The Actor collects public product-opinion data. You are responsible for using it lawfully and in accordance with applicable terms, privacy rules, database rights, and intellectual-property requirements.

Reviewer names are already masked by Allegro, but opinion text can still contain personal information. Store only the fields needed for your purpose, restrict access, set an appropriate retention period, and honor valid deletion or correction requests.

Do not use review data to harass, identify, or profile individual buyers. Do not present automated sentiment or translation as a statement made by Allegro or the reviewer.

For legal guidance, see Apify's overview of [web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### Related Automation Lab Actor

#### [Allegro.pl Product Scraper](https://apify.com/automation-lab/allegro-scraper)

Use this related Actor to discover Allegro listing cards and collect prices, sellers, images, delivery details, product parameters, and aggregate review counts.

A common workflow is:

1. discover candidate products with Allegro.pl Product Scraper;
2. retain canonical product UUIDs for the products you monitor;
3. collect individual opinions with Allegro Reviews Scraper;
4. join the two datasets by your product mapping.

### FAQ

#### Can I scrape several products in one run?

Yes. Add several canonical URLs or UUIDs. The maximum review limit is applied to each unique product.

#### Can I filter for critical reviews?

Yes. Set `minRating` to `1` and `maxRating` to `3`, or choose another rating band.

#### Can I download CSV or Excel?

Yes. Apify datasets support JSON, CSV, Excel, XML, and other export formats.

#### Can I schedule recurring monitoring?

Yes. Use Apify schedules, then deduplicate snapshots downstream with `productId` and `reviewId`.

#### Does it return buyer-uploaded photos?

Yes, when the public opinion includes images. Use `withImagesOnly` to keep only those opinions.

#### Does it work without an Allegro API key?

Yes. No Allegro credential is required.

#### Does it support Allegro Poland, Czechia, Slovakia, and Hungary URLs?

Canonical product URLs on `allegro.pl`, `allegro.cz`, `allegro.sk`, and `allegro.hu` are accepted when the URL contains a product UUID. The returned opinion locale depends on Allegro's public data.

#### Are empty fields errors?

No. Optional source fields are represented by nulls or empty arrays. A malformed response shape, unsupported URL, or upstream HTTP failure causes a non-zero run failure.

# Actor input Schema

## `startUrls` (type: `array`):

Canonical Allegro /produkt/ URLs containing a product UUID. Offer-only /oferta/ and /nabidka/ URLs are not supported because they do not expose the public product identifier.

## `productIds` (type: `array`):

Product UUIDs copied from canonical Allegro /produkt/ URLs. Use this for bulk or scheduled workflows that already store product identifiers.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of matching opinion records saved for each product.

## `minRating` (type: `number`):

Keep opinions with this star rating or higher.

## `maxRating` (type: `number`):

Keep opinions with this star rating or lower. Combine with minimum rating to analyze a rating band.

## `withImagesOnly` (type: `boolean`):

Save only buyer opinions that contain at least one public review image.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://allegro.pl/produkt/korki-adidas-f50-elite-ag-buty-pilkarskie-lanki-na-sztuczna-trawe-orlik-4549a95f-0be1-41b3-954f-015bea7131b3?offerId=18016530911"
    }
  ],
  "maxReviewsPerProduct": 20,
  "minRating": 1,
  "maxRating": 5,
  "withImagesOnly": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all extracted Allegro review records.

# 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 = {
    "startUrls": [
        {
            "url": "https://allegro.pl/produkt/korki-adidas-f50-elite-ag-buty-pilkarskie-lanki-na-sztuczna-trawe-orlik-4549a95f-0be1-41b3-954f-015bea7131b3?offerId=18016530911"
        }
    ],
    "maxReviewsPerProduct": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/allegro-reviews-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 = {
    "startUrls": [{ "url": "https://allegro.pl/produkt/korki-adidas-f50-elite-ag-buty-pilkarskie-lanki-na-sztuczna-trawe-orlik-4549a95f-0be1-41b3-954f-015bea7131b3?offerId=18016530911" }],
    "maxReviewsPerProduct": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/allegro-reviews-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 '{
  "startUrls": [
    {
      "url": "https://allegro.pl/produkt/korki-adidas-f50-elite-ag-buty-pilkarskie-lanki-na-sztuczna-trawe-orlik-4549a95f-0be1-41b3-954f-015bea7131b3?offerId=18016530911"
    }
  ],
  "maxReviewsPerProduct": 20
}' |
apify call automation-lab/allegro-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/allegro-reviews-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/FjX1upIQCMURXxjgv/builds/tkxHpj8rWryaHbwrF/openapi.json