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

Scrape Allegro.pl products by keyword, category, seller or offer URL — pure HTTP, no browser. Each row: price (+ original), seller rating, condition, parameters, images, Smart!/sponsored, offer count & recent-buyer sales-velocity. Deep mode adds rating+reviews, stock, GTIN, warranty. JSON/CSV

- **URL**: https://apify.com/memo23/allegro-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 21 total users, 14 monthly users, 98.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.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/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.pl Product Scraper — Prices, Sellers, Stock & Specs

Scrape **product listings from [Allegro.pl](https://allegro.pl)** — Poland's #1 online marketplace — at scale. Search by keyword, browse any category, or paste direct offer / seller URLs, and get back clean, structured rows: **price (current + original), seller reputation, condition, parameters, images, delivery, Smart!/sponsored flags, how many sellers carry the product, and a real sales-velocity signal** ("how many people bought it recently"). Turn on **deep mode** to also pull full description, complete spec table, **rating + reviews, stock quantity, GTIN/EAN, warranty and return policy** from each offer page.

Pure HTTP — **no browser** — so it's fast, light and cheap per product.

![How the Allegro.pl Product Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-allegro.png)

### Why use this Allegro scraper

- 🟠 **Everything in one row.** Price, delivery, seller rating, condition, parameters and images come straight from the search results — no detail-page visit required.
- 📈 **Signals competitors don't expose.** Sales-velocity popularity ("21 people bought recently"), `productOffersCount` (how many sellers list the same product), Smart! eligibility, sponsored vs organic, and **original (pre-discount) price**.
- 🔍 **Deep mode when you need it.** Optionally enrich each product with full description, the complete parameter table, **star rating + review count + score distribution**, exact **stock quantity**, **GTIN/EAN**, warranty and return policy, and full-resolution images.
- 🧭 **Four ways in.** Keyword search, category URL, a seller's whole storefront, or specific offer URLs — auto-detected.
- ⚡ **No browser, no rate-limit babysitting.** A managed proxy bypasses Allegro's anti-bot wall; the actor reads Allegro's own embedded JSON, paginates and dedupes for you.
- 💸 **Pay per product.** One row = one charge. Listing mode pulls ~60 products per request.

### Overview

Allegro.pl is the largest e-commerce platform in Poland and Central Europe, with tens of millions of offers. This actor extracts product data from it without a headless browser: it requests the same pages your browser does (through a managed proxy that clears the DataDome challenge), reads the structured JSON Allegro embeds in every listing and offer page, and normalizes it into one tidy record per product.

It works for **price monitoring, competitor and assortment analysis, sourcing, market research, and price-comparison feeds** — at the scale of thousands of products per run.

### Supported inputs

| Input | Example | What you get |
|---|---|---|
| **Search query** | `laptop gaming` | Every matching offer, paginated, with your 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 |
| **Offer URL** | `https://allegro.pl/oferta/18581001532` | A single product (always full-detail) |

Mix them freely — provide a list of search queries and a list of start URLs in the same run.

### Use cases

- **Competitor price tracking** — monitor prices, discounts and Smart! eligibility across sellers over time.
- **Market & assortment research** — map an entire category, see which products sell (sales-velocity), and how many sellers carry each one.
- **Sourcing & procurement** — shortlist suppliers by seller rating, feedback count and stock depth; match products by GTIN/EAN.
- **Price-comparison & catalog apps** — feed real, structured Allegro product data into your own shopping or comparison engine.
- **Business intelligence** — push product-level pricing and demand signals into dashboards.
- **Brand & MAP monitoring** — track who sells your products, at what price, and whether listings are sponsored.

### How it works

1. **Bypass the anti-bot wall.** Every request is routed through a managed proxy (scrape.do) that clears Allegro's DataDome challenge and returns the fully-formed page — no browser needed.
2. **Read the embedded JSON.** Allegro ships a `__listing_StoreState` object in each listing page and a deep `facade` object in each offer page. The actor parses those directly, so all fields are structured (not scraped off the rendered DOM).
3. **Paginate & dedupe.** It walks pages (~60 products each, up to Allegro's 100-page cap) until your per-query limit is reached, deduping by `offerId`.
4. **Optionally go deep.** With **Scrape full product details** enabled, it visits each `/oferta/` page and merges the rich offer dataset onto the row.
5. **Normalize.** One clean record per product, tagged with its source query/URL and scrape timestamp.

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | `["laptop gaming"]` | Keywords to search; each runs its own paginated crawl. |
| `startUrls` | array | `[]` | Direct Allegro offer / search / category / seller URLs. |
| `maxItemsPerQuery` | integer | `100` | Max products per query or per listing URL (≤ ~6000). |
| `minPrice` / `maxPrice` | integer | — | Price range filter in PLN (`price_from` / `price_to`). |
| `condition` | select | `all` | `all`, `new` (nowe) or `used` (używane). |
| `sortBy` | select | `relevance` | `relevance`, `price-asc`, `price-desc`, `newest`. |
| `scrapeProductDetails` | boolean | `false` | Visit each offer page for the deep dataset (1 extra request/product). |
| `includeRawData` | boolean | `false` | Attach the raw Allegro offer object (deep mode only). |
| `geoCode` | string | `pl` | Proxy exit country (keep `pl` for allegro.pl pricing). |

#### Example input

```json
{
  "searchQueries": ["laptop gaming", "iphone 15"],
  "minPrice": 500,
  "maxPrice": 5000,
  "condition": "new",
  "sortBy": "price-asc",
  "maxItemsPerQuery": 200,
  "scrapeProductDetails": true
}
````

### Output overview

One row per product. **Listing fields** are always present; **`detail`** is populated only when *Scrape full product details* is on.

#### Output sample (one product)

```json
{
  "offerId": "18301984000",
  "productId": "8e2abfdd-4b19-4384-beee-7d9c5f8dadd6",
  "url": "https://allegro.pl/oferta/szklo-hartowane-9h-kong-...-18301984000",
  "title": "Szkło hartowane KONG do Apple iPhone 15, iPhone 16 1 szt.",
  "brand": "KONG",
  "price": { "amount": 14.99, "currency": "PLN" },
  "originalPrice": null,
  "priceWithDelivery": { "amount": 25.48, "currency": "PLN" },
  "condition": "Nowy",
  "delivery": { "free": false, "freeReturn": false, "lowestCost": { "amount": 10.49, "currency": "PLN" }, "label": "25,48 zł z dostawą" },
  "seller": { "id": "142221614", "login": "Kong", "name": "Firma", "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": 555 },
  "rating": { "value": 4.9, "count": 97 },
  "parameters": [ { "name": "Stan", "value": "Nowy" }, { "name": "Marka", "value": "KONG" } ],
  "images": ["https://a.allegroimg.com/original/116f16/...-iPhone-16-15"],
  "categoryId": "10532",
  "searchQuery": "iphone 15 szkło hartowane",
  "scrapedAt": "2026-06-27T12:47:00.000Z",
  "detail": {
    "stock": { "available": 3689, "label": "z 3 689 sztuk", "unit": "UNIT" },
    "gtin": "5907494722515",
    "rating": { "value": 4.9, "count": 97, "title": "Rewelacyjny", "reviewsCount": 39, "bestOpinion": "Bardzo polecam...", "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": "producenta/dystrybutora", "label": "..." },
    "breadcrumbs": ["Allegro", "Elektronika", "Telefony i Akcesoria", "Akcesoria GSM", "Folie i szkła ochronne"],
    "parameterGroups": [ { "group": "Dane podstawowe", "parameters": [ { "name": "Stan", "value": "Nowy" } ] } ],
    "description": "…full product description text…",
    "images": ["https://a.allegroimg.com/original/...full-res…"]
  }
}
```

### Key output fields

| Field | Description |
|---|---|
| `offerId` | Allegro offer id (stable key; `allegro.pl/oferta/{offerId}` resolves to the offer). |
| `productId` | Allegro product (catalog) id — same product across many sellers. |
| `title` · `brand` | Offer title and brand. |
| `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. |
| `condition` | Nowy (new) / Używany (used) / etc. |
| `seller` | id, login, company flag, **superSeller**, **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. |
| `parameters` · `images` | Spec name/value pairs and product images. |
| **`detail.stock`** | Exact available quantity. |
| **`detail.gtin`** | GTIN/EAN barcode (deep mode). |
| **`detail.rating`** | Average, count, verbal grade, review count, score distribution, featured opinion. |
| **`detail.warranty` · `detail.returnPolicy`** | Warranty period/type and return terms. |
| **`detail.description` · `detail.parameterGroups`** | Full description and grouped spec table. |

### FAQ

**Do I need a proxy or any setup?** No. The actor handles the anti-bot bypass itself and runs self-contained.

**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 in rating, reviews, stock, GTIN, warranty, return policy and the full description from each offer page.

**Is text in Polish?** Yes — titles, conditions, parameter names and descriptions are Allegro's original Polish. Prices are in PLN.

**How many products can I get per query?** Allegro serves ~60 products per page and caps results at 100 pages, so up to ~6,000 products per query/URL. Use multiple queries or category/seller URLs to go wider.

**Does it work for allegro.cz / .sk / .hu?** The same engine handles those Allegro domains; this actor is tuned and verified for **allegro.pl**.

**Will listing-mode and deep-mode cost the same?** You're charged per product row either way. Deep mode just does one extra fetch per product behind the scenes (slower, more proxy credits), but the per-result price is the same.

### Support

Questions, a field you'd like added, or a site change to report? Open an issue on the actor's **Issues** tab or email **muhameddidovic@gmail.com**. Response within 24 hours.

### Additional services

Need a custom feed (scheduled runs, push to your DB/webhook, extra fields, or another Allegro domain)? Reach out — happy to tailor it.

### Explore more scrapers

Looking for other marketplaces or e-commerce sources? Check out the rest of the [memo23 actor collection](https://apify.com/memo23) on the Apify Store — Blinkit, and more product, travel and directory scrapers.

### ⚠️ Disclaimer

This actor extracts **publicly available** product information from Allegro.pl. It does not log in, bypass paywalls, or collect personal/private data. Use the data in compliance with Allegro's Terms of Service, applicable laws (including GDPR), and copyright. You are responsible for how you use the scraped data. This tool is intended for legitimate purposes such as price monitoring, market research and competitive analysis.

### SEO Keywords

Allegro scraper, Allegro.pl scraper, Allegro product scraper, Allegro price scraper, Allegro API, scrape Allegro, Allegro data extraction, Allegro price monitoring, Allegro competitor analysis, Allegro marketplace scraper, Poland e-commerce scraper, Allegro seller scraper, Allegro category scraper, Allegro offer scraper, Allegro product data, Allegro price comparison, Allegro stock checker, Allegro GTIN EAN, Allegro reviews scraper, Apify Allegro.

# 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. Runs in addition to search queries.

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

Upper bound of products to extract per search query or per listing URL. Allegro serves ~60 products/page and caps at 100 pages (~6000 max per query). Also capped by your plan and charge limit.

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

Only return offers priced at or above this value, in Polish złoty (PLN). Maps to Allegro's price\_from filter.

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

Only return offers priced at or below this value, in Polish złoty (PLN). Maps to Allegro's price\_to filter.

## `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, stock quantity, GTIN/EAN, warranty, return policy, full seller reputation and full-resolution images. Costs one extra request per product (slower + more credits). Leave off for fast, rich listing-level data.

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

Attach the raw Allegro offer object to each detailed record. Only applies when "Scrape full product details" is on. For debugging / power users.

## `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). Higher = much faster for large runs (e.g. thousands of barcode/EAN lookups); 30–50 recommended for big detail runs. Default 10.

## Actor input object example

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

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "laptop gaming"
    ],
    "startUrls": [],
    "maxItemsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 gaming"],
    "startUrls": [],
    "maxItemsPerQuery": 20,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Allegro.pl Product Scraper — Prices, Sellers, Stock & Specs",
        "description": "Scrape Allegro.pl products by keyword, category, seller or offer URL — pure HTTP, no browser. Each row: price (+ original), seller rating, condition, parameters, images, Smart!/sponsored, offer count & recent-buyer sales-velocity. Deep mode adds rating+reviews, stock, GTIN, warranty. JSON/CSV",
        "version": "0.0",
        "x-build-id": "OrPQFWhXJ7eDgpym6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~allegro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-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/memo23~allegro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-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/memo23~allegro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-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 queries",
                        "type": "array",
                        "description": "Keywords to search on Allegro.pl. Each keyword runs its own paginated crawl. Example: \"laptop gaming\", \"iphone 15\", \"lego technic\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "📎 Start URLs (optional)",
                        "type": "array",
                        "description": "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. Runs in addition to search queries.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItemsPerQuery": {
                        "title": "Max products per query / URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound of products to extract per search query or per listing URL. Allegro serves ~60 products/page and caps at 100 pages (~6000 max per query). Also capped by your plan and charge limit.",
                        "default": 100
                    },
                    "minPrice": {
                        "title": "Min price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return offers priced at or above this value, in Polish złoty (PLN). Maps to Allegro's price_from filter."
                    },
                    "maxPrice": {
                        "title": "Max price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return offers priced at or below this value, in Polish złoty (PLN). Maps to Allegro's price_to filter."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "all",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter by product condition (Allegro's \"stan\" filter).",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Order of the search/category results.",
                        "default": "relevance"
                    },
                    "scrapeProductDetails": {
                        "title": "Scrape full product details (deep mode)",
                        "type": "boolean",
                        "description": "Visit each offer page for the deep dataset: full description, complete parameter table, rating + review count, stock quantity, GTIN/EAN, warranty, return policy, full seller reputation and full-resolution images. Costs one extra request per product (slower + more credits). Leave off for fast, rich listing-level data.",
                        "default": false
                    },
                    "includeRawData": {
                        "title": "Include raw data",
                        "type": "boolean",
                        "description": "Attach the raw Allegro offer object to each detailed record. Only applies when \"Scrape full product details\" is on. For debugging / power users.",
                        "default": false
                    },
                    "geoCode": {
                        "title": "Proxy exit country",
                        "type": "string",
                        "description": "Country the request exits from (Allegro localises prices/availability by IP). Default \"pl\" (Poland) is correct for allegro.pl.",
                        "default": "pl"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many products/pages to fetch in parallel (1–50). Higher = much faster for large runs (e.g. thousands of barcode/EAN lookups); 30–50 recommended for big detail runs. Default 10.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
