# Allegro Scraper (`maximedupre/allegro-scraper`) Actor

Scrape Allegro product listings from search terms, listing URLs, or category URLs. Get prices, seller names, images, delivery text, item condition, and product parameters.

- **URL**: https://apify.com/maximedupre/allegro-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.10 / 1,000 scraped products

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 for Product Listing Data

Allegro Scraper collects product listing data from [Allegro](https://allegro.pl/) search results, category pages, and listing URLs. Use it to export product titles, prices, seller names, item condition, images, delivery text, category IDs, product parameters, source URLs, and rank metadata into an Apify dataset.

Start with the prefilled `laptop` search and a small product limit. Once the output shape looks right, add more Allegro search terms or paste the exact Allegro URLs you want to monitor.

### ✅ What This Actor Does

This Allegro scraper is built for ecommerce research, price checks, assortment research, and marketplace reporting. It accepts plain search terms when you want a broad product search, and it accepts Allegro URLs when you already know the category or listing page you care about.

You can scrape:

- Allegro search terms such as `laptop`, `iphone 15`, or `ekspres do kawy`
- Allegro search and listing URLs
- Allegro category URLs

Each accepted product is saved as soon as it is collected, so you can watch the dataset fill during the run. The Actor focuses on product listing cards. It does not scrape reviews, questions, checkout data, private account data, or full product-page descriptions.

### 📦 Data You Can Extract

Each dataset item is one Allegro product listing. Fields can include:

- `offerId` - Allegro offer ID.
- `productId` - product or listing product ID when shown.
- `title` - product title from the listing card.
- `url` - clean Allegro product or offer URL.
- `price` and `currency` - visible product price, usually in PLN.
- `condition` - visible item condition when Allegro shows it.
- `sellerName` and `sellerId` - seller details from the listing.
- `sellerPositiveFeedbackPercent` - seller feedback percentage when visible.
- `isSuperSeller` - whether the listing or seller is marked as a Super Seller.
- `isSponsored` - whether the listing is marked as sponsored.
- `imageUrl` - main product image URL.
- `deliveryText` - visible delivery or price-with-delivery text.
- `categoryId` - Allegro category ID when exposed on the card.
- `parameters` - visible product parameters such as screen size, processor series, keyboard layout, or disk type.
- `sourceTarget`, `sourceUrl`, `pageNumber`, `searchRank`, and `scrapedAt` - metadata for tracking where each row came from.

Some fields can be empty when Allegro does not show that information on the listing card.

### 🧭 Common Use Cases

- Track Allegro prices for a keyword or category.
- Compare sellers and offer counts in a product niche.
- Build product lists for ecommerce research.
- Monitor sponsored and organic product placement.
- Export listing data to CSV, JSON, Excel, Google Sheets, webhooks, or your own API workflow.
- Schedule repeat runs on Apify for recurring price or assortment checks.

### 🚀 How To Run

1. Add one or more values to **Search terms**, or paste Allegro pages into **Allegro URLs**.
2. Set **Product limit per source**. Use `25` to `50` for a first run.
3. Choose a sort order for search terms if needed.
4. Add optional price filters.
5. Leave **Deduplicate offers** on unless you want repeated offers from overlapping sources.
6. Run the Actor and open the dataset.

The Actor does not ask for an Allegro login, cookies, or an Allegro API key.

### ⚙️ Input Options

| Field | What it does |
| --- | --- |
| `searchQueries` | Allegro search terms to scrape. |
| `startUrls` | Allegro listing or category URLs to scrape. |
| `maxProductsPerSource` | Maximum product rows saved for each search term or URL. |
| `sort` | Sort order for search terms: relevance, price low to high, price high to low, or newest. |
| `minPrice` | Saves only products at or above this visible price in PLN. |
| `maxPrice` | Saves only products at or below this visible price in PLN. |
| `deduplicateProducts` | Saves each Allegro offer once across the run. |

### 🧾 Output Example

```json
{
	"offerId": "18581001532",
	"productId": "fec071f8-4391-49bc-84ce-87939d67b798",
	"title": "Mobilna stacja robocza Lenovo ThinkPad P52 i7 32 GB 1 TB SSD NVIDIA W11P",
	"url": "https://allegro.pl/oferta/mobilna-stacja-robocza-lenovo-thinkpad-p52-i7-32-gb-1-tb-ssd-nvidia-w11p-18581001532",
	"price": 1799,
	"currency": "PLN",
	"condition": "Używany",
	"sellerName": "JB-S",
	"sellerPositiveFeedbackPercent": 98.9,
	"isSponsored": true,
	"imageUrl": "https://a.allegroimg.com/s180/...",
	"deliveryText": "1809,49 zł z dostawą",
	"categoryId": "491",
	"parameters": {
		"Stan": ["Używany"],
		"Przekątna ekranu": ["15.6\""],
		"Seria procesora": ["Intel Core i7"]
	},
	"sourceTarget": "laptop",
	"pageNumber": 1,
	"searchRank": 1,
	"scrapedAt": "2026-05-31T14:30:01.213Z"
}
````

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each product collected from Allegro listing results. If a run starts but no products are saved, there is no product charge from this Actor's primary event.

Keep the product limit low for your first run, check the dataset, then raise the limit for larger searches or scheduled monitoring.

### ⚠️ Limits And Caveats

The Actor reads data visible on Allegro listing pages. It does not open every product page for long descriptions, reviews, Q\&A, full seller profiles, checkout data, or private account information.

Allegro may show different products depending on source page, filters, ranking, availability, sponsorship, and marketplace changes. If Allegro does not expose a field on the listing card, the matching output field may be `null`.

### ❓ FAQ

#### ❓ Do I need an Allegro account?

No. The input form does not require Allegro login details, cookies, or an Allegro API key.

#### 🗂️ Can I use category URLs?

Yes. Paste an Allegro category URL into **Allegro URLs**, optionally with the filters already present in the URL.

#### 💬 Does it scrape product reviews?

No. This Actor focuses on product listing data: prices, sellers, condition, images, delivery text, and visible parameters.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~allegro-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Trendyol Scraper ↗](https://apify.com/maximedupre/trendyol-scraper) - Scrape Trendyol product data and optional customer reviews.
- [Mercado Libre Search Scraper ↗](https://apify.com/maximedupre/mercado-libre-search-scraper) - Collect Mercado Libre product search results across supported markets.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Export paid Google Shopping product ads for ecommerce keywords.
- [Etsy Keywords Research Tool ↗](https://apify.com/maximedupre/etsy-keywords-research-tool) - Collect Etsy autocomplete keyword suggestions for listing research.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Collect Pinterest autocomplete suggestions for content and SEO research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Enter Allegro product searches such as laptop, iphone 15, ekspres do kawy, or a brand plus product type. Each term runs as its own source.

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

Paste Allegro listing or category URLs when you already have the exact page to collect. You can mix URLs and search terms in the same run.

## `maxProductsPerSource` (type: `integer`):

Maximum product rows to save for each search term or URL. Use 25-50 for a quick first run.

## `sort` (type: `string`):

Sort order for search terms. Full Allegro URLs keep their own source filters when possible.

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

Only save products at or above this visible Allegro price in PLN.

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

Only save products at or below this visible Allegro price in PLN.

## `deduplicateProducts` (type: `boolean`):

Save each Allegro offer once when it appears in multiple searches or URLs.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop"
  ],
  "startUrls": [],
  "maxProductsPerSource": 50,
  "sort": "relevance",
  "deduplicateProducts": true
}
```

# Actor output Schema

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

Open the dataset with Allegro product listing rows.

# 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"
    ],
    "startUrls": []
};

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

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

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ],
  "startUrls": []
}' |
apify call maximedupre/allegro-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/allegro-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Allegro Scraper",
        "description": "Scrape Allegro product listings from search terms, listing URLs, or category URLs. Get prices, seller names, images, delivery text, item condition, and product parameters.",
        "version": "0.1",
        "x-build-id": "MttWE7rY7PTpx19LN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~allegro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-allegro-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~allegro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-allegro-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~allegro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-allegro-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Enter Allegro product searches such as laptop, iphone 15, ekspres do kawy, or a brand plus product type. Each term runs as its own source.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "startUrls": {
                        "title": "Allegro URLs",
                        "type": "array",
                        "description": "Paste Allegro listing or category URLs when you already have the exact page to collect. You can mix URLs and search terms in the same run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "description": "An Allegro listing or category URL.",
                                    "type": "string",
                                    "pattern": "^https?://"
                                }
                            }
                        }
                    },
                    "maxProductsPerSource": {
                        "title": "Product limit per source",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum product rows to save for each search term or URL. Use 25-50 for a quick first run.",
                        "default": 50
                    },
                    "sort": {
                        "title": "Sort products by",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Sort order for search terms. Full Allegro URLs keep their own source filters when possible.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only save products at or above this visible Allegro price in PLN."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only save products at or below this visible Allegro price in PLN."
                    },
                    "deduplicateProducts": {
                        "title": "Deduplicate offers",
                        "type": "boolean",
                        "description": "Save each Allegro offer once when it appears in multiple searches or URLs.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
