# Allegro Scraper | PL CZ SK HU Prices Sellers Offers (`lentic_clockss/allegro-scraper`) Actor

Scrape Allegro.pl, Allegro.cz, Allegro.sk & Allegro.hu — search, categories, Strefa Okazji deals, sellers, product hubs, multi-offers & EAN. Extract offerId, prices, sellers, ads flags. Export Excel/CSV/JSON. Unofficial — not affiliated with Allegro.

- **URL**: https://apify.com/lentic\_clockss/allegro-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 — Products, Prices & Sellers (PL / CZ / SK / HU)

**Scrape Allegro.pl, Allegro.cz, Allegro.sk, and Allegro.hu product listings — then download structured marketplace data as Excel, CSV, or JSON.**

Use this Actor as a practical **Allegro marketplace data API** for Central European price monitoring, category research, deal tracking, seller catalogs, EAN lookups, and multi-offer comparison. Pick a country, choose a mode, and get Dataset rows with `offerId`, titles, prices, currency, sellers, and permalinks.

- Scrape **keyword search**, **categories**, **department browse**, **Strefa Okazji / deals**, **product hubs**, **multi-seller offers**, **single offers**, and **seller shops**
- Cover **allegro.pl**, **allegro.cz**, **allegro.sk**, and **allegro.hu** (+ Allegro Lokalnie & Wakacje modes)
- Extract **offerId**, **productId (UUID)**, price, currency, seller login, ads/sponsored flags, `sellingMode`, brand, GTIN, parameters, and images
- Filter by **price**, **condition**, **buy now**, **free shipping**, **city**, and verified **sort** codes
- Export to **Excel / CSV / JSON**, or connect Make, n8n, Zapier, Python, or the Apify API
- **Pay per event** — Actor start + each Dataset result; **platform usage is included** (you do not pay separate Apify compute on top)

> **Unofficial tool.** This Actor is not affiliated with, endorsed by, or sponsored by Allegro.pl Sp. z o.o. or Allegro Group. It collects publicly reachable listing surfaces and does **not** place orders, checkout, or access private accounts.

---

### What does the Allegro Scraper do?

Allegro Scraper lets you **extract structured ecommerce data from Allegro marketplaces** without operating your own anti-bot browser fleet. Give it a country and a mode (for example `search`, `category`, or `deals`), then start a run.

Under the hood, the Actor:

1. Validates your input (mode, country / domain, filters, max results)
2. Enforces free-tier caps when you are on a free Apify plan
3. Calls a managed Cloud Run worker (`allegro-pl`) that opens public pages with residential egress (Camoufox)
4. Parses listing / detail signals into normalized Dataset records
5. Optionally enriches up to `min(maxResults, 20)` rows with brand, GTIN, parameters, and images
6. Writes `RUN_SUMMARY` (and `ERROR_SUMMARY` on failure) to the key-value store

You run it like any other Apify Actor — schedule it, call it from the API, or plug it into automations.

---

### What Allegro data can I extract?

| Data | Search | Category | Deals | Product / offers | Seller | EAN | Lokalnie |
| --- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
| offerId / productId | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅* |
| Title | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅* |
| Price / currency | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅* |
| Seller login / id | ✅* | ✅* | ✅* | ✅ | ✅ | ✅* | ✅* |
| URL / sourceHost | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| Sponsored / promoted | ✅* | ✅* | ✅* | ✅* | ✅* | — | — |
| sellingMode (BUY_NOW / AUCTION) | ✅* | ✅* | ✅* | ✅* | ✅* | — | — |
| Brand / GTIN / parameters / images | enrich | enrich | enrich | ✅ | enrich | enrich | — |
| Category tree nodes | — | — | — | — | — | — | — |

\*When present on the page or script state. Use `mode=categories` for department / leaf category nodes. `enrichDetails=true` deepens brand/GTIN/params/images.

---

### Why scrape Allegro?

Allegro is the leading ecommerce marketplace network in Poland and a major player across Czechia, Slovakia, and Hungary. Teams scrape Allegro to:

- Monitor **PLN / CZK / EUR / HUF** prices and promotions across markets
- Track **Strefa Okazji** deals and category assortments
- Compare **multi-seller offers** on the same product UUID
- Look up products by **EAN / GTIN** and enrich catalogs with brand / parameters
- Follow **seller storefronts** and optional in-shop category filters
- Capture **Lokalnie** local listings and **Wakacje** travel rows when needed

Compared with Allegro Actors that only cover **allegro.pl**, **search-only**, or **EAN-only / reviews-only**, this Actor focuses on **multi-country marketplace coverage** (PL/CZ/SK/HU) with search, categories, deals, sellers, product hubs, and EAN in one input form.

---

### How to scrape Allegro (no code required)

1. Create a free [Apify](https://apify.com/) account
2. Open [Allegro Scraper](https://apify.com/lentic_clockss/allegro-scraper)
3. Choose a **mode**: `search`, `category`, `categories`, `department`, `deals`, `product`, `product_offers`, `offer`, `seller`, `lokalnie`, `ean`, `image_search`, or `wakacje`
4. Choose a **country**: `pl` (default), `cz`, `sk`, or `hu`
5. Enter a **query**, **categoryId**, **productId**, **offerId**, **sellerLogin**, **eans**, or **startUrls**
6. *(Optional)* Set `order`, `priceFrom` / `priceTo`, `condition`, `city`, `enrichDetails`, `maxResults`
7. Click **Start** and download the Dataset as JSON, CSV, Excel, or JSONL

Start with `maxResults: 5–10` to verify the query, then scale up.

---

### How much does it cost to scrape Allegro?

This Actor uses **pay-per-event** pricing. You are charged for:

| Event | Price |
| --- | --- |
| Actor Start (`apify-actor-start`) | **$0.005** per start |
| Result (`apify-default-dataset-item`) | **$3.00 / 1,000** results (**$0.003** each) |

**Platform usage costs are included** — you do **not** pay separate Apify compute/proxy usage for this Actor on top of the event prices above.

#### Example cost estimates

| Results collected | Approx. event cost* |
| --- | ---: |
| 100 | ~$0.31 |
| 1,000 | ~$3.01 |
| 10,000 | ~$30.01 |

\*Assumes one Actor start at default memory billing for start events, plus `$0.003` per Dataset item. Exact start billing can scale with allocated memory (one start event per GB, minimum one).

Free Apify trial credit can cover a small test run — try `maxResults: 5` first.

#### Free Apify plan limits (Actor-enforced)

| Cap | Free Apify plan | Paying |
| --- | --- | --- |
| Runs of this Actor | **10** total | Unlimited |
| Results per run | **200** | Schema max (500) |

Limits are set by the Actor developer, not Apify. Quota hits return `SUCCEEDED` with `RUN_SUMMARY.status=FREE_TIER_LIMIT`.

---

### Input examples

#### Keyword search (Poland)

```json
{
  "mode": "search",
  "country": "pl",
  "query": "mysz bezprzewodowa logitech",
  "order": "p",
  "priceFrom": 50,
  "maxResults": 20,
  "enrichDetails": true
}
````

#### Category browse (Czechia)

```json
{
  "mode": "category",
  "country": "cz",
  "categoryId": "257228",
  "categorySlug": "smartfony-a-mobily",
  "p": 1,
  "maxResults": 30
}
```

#### Strefa Okazji deals

```json
{
  "mode": "deals",
  "country": "pl",
  "maxResults": 25
}
```

#### Multi-seller product offers

```json
{
  "mode": "product_offers",
  "country": "pl",
  "productId": "00000000-0000-0000-0000-000000000000",
  "maxResults": 50
}
```

#### EAN / GTIN lookup

```json
{
  "mode": "ean",
  "country": "pl",
  "eans": ["5901234123457"],
  "maxResults": 20
}
```

#### Category tree

```json
{
  "mode": "categories",
  "country": "pl",
  "maxResults": 50
}
```

***

### Coverage matrix

| Dimension | Coverage |
| --- | --- |
| Countries | `pl` · `cz` · `sk` · `hu` (+ `allegrolokalnie.pl`, `wakacje.allegro.pl`) |
| Modes | `search` `category` `categories` `department` `deals` `product` `product_offers` `offer` `seller` `lokalnie` `ean` `image_search` `wakacje` |
| Search paths | PL `/listing` · CZ `/vyhledavani` · SK `/vyhladavanie` · HU `/listing` |
| Offer paths | PL `/oferta` · CZ `/nabidka` · SK `/ponuka` · HU `/ajanlat` |
| Sort (`order`) | Verified: `m` `p` `pd` `d` `n` `qd` |
| Filters | `priceFrom` `priceTo` `condition` `buyNow` `freeShipping` `offerType` `seller` `city` |

***

### Output example

```json
{
  "recordType": "offer",
  "offerId": "12345678901",
  "productId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "title": "Mysz Bezprzewodowa Logitech MX MASTER 3S",
  "price": 449.0,
  "currency": "PLN",
  "url": "https://allegro.pl/oferta/...",
  "domain": "allegro.pl",
  "country": "pl",
  "seller": { "login": "example-shop", "superSeller": true },
  "promoted": false,
  "sellingMode": "BUY_NOW",
  "brand": "Logitech",
  "gtin": "5099206107885",
  "scrapedAt": "2026-07-27T12:00:00Z"
}
```

***

### Integrations & API

- **Apify API / Client** — start runs and pull Dataset items programmatically
- **Schedules** — daily / hourly price monitors
- **Webhooks** — notify your backend when a run finishes
- **Make / n8n / Zapier** — no-code pipelines into Sheets, Slack, or warehouses
- **Standby mode** — HTTP proxy surface for low-latency integrations (`/search`)

Default run memory: **1024 MB** (thin HTTP Actor; browser work runs on the managed worker).

***

### FAQ

#### Is this an official Allegro API?

No. This is an **unofficial scraper** for publicly reachable Allegro pages. It is not the Allegro Developer API and is not affiliated with Allegro.

#### Which countries are supported?

**Poland (`pl`)**, **Czechia (`cz`)**, **Slovakia (`sk`)**, and **Hungary (`hu`)**. Lokalnie and Wakacje modes use their dedicated hosts when available.

#### Why do some runs return `blocked`?

Allegro uses DataDome and similar protections. The managed worker uses residential egress and Camoufox; occasional blocks still happen (especially on harder markets like HU). Check `RUN_SUMMARY` / warnings — the Actor does **not** invent empty “success” rows when a page is blocked.

#### What does `enrichDetails` do?

When enabled, the worker follows up to `min(maxResults, 20)` listing URLs to add brand, GTIN, parameters, images, delivery cost, and related detail fields. It is slower and uses more worker time.

#### Can I scrape by EAN / barcode?

Yes — set `mode=ean` and pass `eans` (or `ean`). Results are resolved via page search paths (not Allegro’s official developer token).

#### Does platform usage cost extra?

**No.** With this Actor’s pay-per-event setup, **users do not pay separate Apify platform usage** on top of Actor Start + result events.

***

### Tips for best results

- Prefer **short verification runs** (`maxResults: 5`) before large jobs
- Use **country-matched proxies** (handled by the worker) — do not mint Apify proxy in the Actor
- For category URLs, pass both **categoryId** and **categorySlug** when you have them
- Enable **enrichDetails** only when you need brand / GTIN / parameters
- Treat `image_search` as advanced: if upload controls are unavailable, the run returns an explicit `unsupported` warning instead of fake rows

***

### Legal & ethical use

Use this Actor only for legitimate purposes and in compliance with applicable laws and Allegro’s terms. Do not scrape personal data you are not entitled to process. Respect rate limits and do not use the data to harm sellers or buyers.

***

### Support

Questions or feature requests? Open an issue on the Actor page or contact the developer via Apify Console.

**Keywords:** Allegro scraper, Allegro.pl scraper, Allegro.cz, Allegro.sk, Allegro.hu, Allegro product scraper, Allegro price scraper, Allegro seller scraper, Strefa Okazji, Allegro Lokalnie, Allegro EAN, Polish marketplace scraper, CEE ecommerce data, offerId, product UUID, pay per event

# Actor input Schema

## `mode` (type: `string`):

search | category | categories | department | deals | product | product\_offers | offer | seller | lokalnie | ean | image\_search | wakacje

## `country` (type: `string`):

Allegro market: pl (default), cz, sk, hu

## `domain` (type: `string`):

allegro.pl | allegro.cz | allegro.sk | allegro.hu | allegrolokalnie.pl | wakacje.allegro.pl

## `query` (type: `string`):

Keyword for search / lokalnie / wakacje

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

Optional list of keywords; first is used when query is empty

## `categoryId` (type: `string`):

Numeric category id for /kategoria/{slug}-{id}

## `categorySlug` (type: `string`):

Optional slug prefix for category / seller subcategory URL

## `categoryIds` (type: `array`):

Optional list; first used when categoryId empty

## `departmentCode` (type: `string`):

e.g. elektronika, moda — for mode=department

## `productId` (type: `string`):

Allegro product catalog UUID

## `offerId` (type: `string`):

Numeric single-seller offer id

## `sellerLogin` (type: `string`):

Seller storefront login

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

Allegro URLs (auto-routed)

## `order` (type: `string`):

Verified: m relevance | p price asc | pd price desc | d price+delivery | n newest | qd popularity

## `p` (type: `integer`):

Category pagination ?p=N

## `maxResults` (type: `integer`):

Maximum offers/products to return. Free plan capped at 200.

## `enrichDetails` (type: `boolean`):

Follow up to min(maxResults,20) listing URLs for brand/gtin/params/images

## `scrapeProductDetails` (type: `boolean`):

Alias of enrichDetails

## `priceFrom` (type: `number`):

Maps to price\_from query param

## `priceTo` (type: `number`):

Maps to price\_to query param

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

Maps to stan= (new|used|…)

## `buyNow` (type: `boolean`):

Maps to buyNow=1

## `freeShipping` (type: `boolean`):

Maps to freeShipping=1

## `offerType` (type: `string`):

Maps to offerType=

## `seller` (type: `string`):

SERP seller= filter (login)

## `city` (type: `string`):

city= filter; recommended for lokalnie

## `experimentalFilters` (type: `object`):

Opaque extra query keys (side-evidence only until Chrome-pinned)

## `shippingCountry` (type: `string`):

Diagnostics-only unless URL-effective

## `eans` (type: `array`):

For mode=ean — barcode reverse lookup via page search

## `ean` (type: `string`):

Single EAN alias

## `imageUrl` (type: `string`):

For mode=image\_search — worker downloads and uploads if control available

## `workerBaseUrl` (type: `string`):

Optional HTTPS Cloud Run override (allowlisted). Production uses Actor env WORKER\_BASE\_URL.

## Actor input object example

```json
{
  "mode": "search",
  "country": "pl",
  "domain": "allegro.pl",
  "order": "m",
  "p": 1,
  "maxResults": 50,
  "enrichDetails": false,
  "scrapeProductDetails": false
}
```

# Actor output Schema

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

Normalized Traveloka hotel / flight / suggestion rows from the default dataset.

## `runSummary` (type: `string`):

Structured summary record stored in the default key-value store.

## `inputEcho` (type: `string`):

Normalized input saved at run start.

## `errorSummary` (type: `string`):

Present when a failed run stores structured terminal error information.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/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 '{}' |
apify call lentic_clockss/allegro-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Allegro Scraper | PL CZ SK HU Prices Sellers Offers",
        "description": "Scrape Allegro.pl, Allegro.cz, Allegro.sk & Allegro.hu — search, categories, Strefa Okazji deals, sellers, product hubs, multi-offers & EAN. Extract offerId, prices, sellers, ads flags. Export Excel/CSV/JSON. Unofficial — not affiliated with Allegro.",
        "version": "0.1",
        "x-build-id": "TbbyefdFnzktX0x6d"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~allegro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-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/lentic_clockss~allegro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-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/lentic_clockss~allegro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "category",
                            "categories",
                            "department",
                            "deals",
                            "product",
                            "product_offers",
                            "offer",
                            "seller",
                            "lokalnie",
                            "ean",
                            "image_search",
                            "wakacje"
                        ],
                        "type": "string",
                        "description": "search | category | categories | department | deals | product | product_offers | offer | seller | lokalnie | ean | image_search | wakacje",
                        "default": "search"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "pl",
                            "cz",
                            "sk",
                            "hu"
                        ],
                        "type": "string",
                        "description": "Allegro market: pl (default), cz, sk, hu",
                        "default": "pl"
                    },
                    "domain": {
                        "title": "Domain",
                        "enum": [
                            "allegro.pl",
                            "allegro.cz",
                            "allegro.sk",
                            "allegro.hu",
                            "allegrolokalnie.pl",
                            "wakacje.allegro.pl"
                        ],
                        "type": "string",
                        "description": "allegro.pl | allegro.cz | allegro.sk | allegro.hu | allegrolokalnie.pl | wakacje.allegro.pl",
                        "default": "allegro.pl"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword for search / lokalnie / wakacje"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional list of keywords; first is used when query is empty",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Numeric category id for /kategoria/{slug}-{id}"
                    },
                    "categorySlug": {
                        "title": "Category slug",
                        "type": "string",
                        "description": "Optional slug prefix for category / seller subcategory URL"
                    },
                    "categoryIds": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "Optional list; first used when categoryId empty",
                        "items": {
                            "type": "string"
                        }
                    },
                    "departmentCode": {
                        "title": "Department code",
                        "type": "string",
                        "description": "e.g. elektronika, moda — for mode=department"
                    },
                    "productId": {
                        "title": "Product UUID",
                        "type": "string",
                        "description": "Allegro product catalog UUID"
                    },
                    "offerId": {
                        "title": "Offer ID",
                        "type": "string",
                        "description": "Numeric single-seller offer id"
                    },
                    "sellerLogin": {
                        "title": "Seller login",
                        "type": "string",
                        "description": "Seller storefront login"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Allegro URLs (auto-routed)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "m",
                            "p",
                            "pd",
                            "d",
                            "n",
                            "qd"
                        ],
                        "type": "string",
                        "description": "Verified: m relevance | p price asc | pd price desc | d price+delivery | n newest | qd popularity",
                        "default": "m"
                    },
                    "p": {
                        "title": "Category page",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Category pagination ?p=N",
                        "default": 1
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum offers/products to return. Free plan capped at 200.",
                        "default": 50
                    },
                    "enrichDetails": {
                        "title": "Enrich details",
                        "type": "boolean",
                        "description": "Follow up to min(maxResults,20) listing URLs for brand/gtin/params/images",
                        "default": false
                    },
                    "scrapeProductDetails": {
                        "title": "Scrape product details",
                        "type": "boolean",
                        "description": "Alias of enrichDetails",
                        "default": false
                    },
                    "priceFrom": {
                        "title": "Price from",
                        "type": "number",
                        "description": "Maps to price_from query param"
                    },
                    "priceTo": {
                        "title": "Price to",
                        "type": "number",
                        "description": "Maps to price_to query param"
                    },
                    "condition": {
                        "title": "Condition",
                        "type": "string",
                        "description": "Maps to stan= (new|used|…)"
                    },
                    "buyNow": {
                        "title": "Buy now only",
                        "type": "boolean",
                        "description": "Maps to buyNow=1"
                    },
                    "freeShipping": {
                        "title": "Free shipping",
                        "type": "boolean",
                        "description": "Maps to freeShipping=1"
                    },
                    "offerType": {
                        "title": "Offer type",
                        "type": "string",
                        "description": "Maps to offerType="
                    },
                    "seller": {
                        "title": "Seller filter",
                        "type": "string",
                        "description": "SERP seller= filter (login)"
                    },
                    "city": {
                        "title": "City / geo",
                        "type": "string",
                        "description": "city= filter; recommended for lokalnie"
                    },
                    "experimentalFilters": {
                        "title": "Experimental filters",
                        "type": "object",
                        "description": "Opaque extra query keys (side-evidence only until Chrome-pinned)"
                    },
                    "shippingCountry": {
                        "title": "Shipping country",
                        "type": "string",
                        "description": "Diagnostics-only unless URL-effective"
                    },
                    "eans": {
                        "title": "EANs / GTINs",
                        "type": "array",
                        "description": "For mode=ean — barcode reverse lookup via page search",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ean": {
                        "title": "EAN",
                        "type": "string",
                        "description": "Single EAN alias"
                    },
                    "imageUrl": {
                        "title": "Image URL",
                        "type": "string",
                        "description": "For mode=image_search — worker downloads and uploads if control available"
                    },
                    "workerBaseUrl": {
                        "title": "Worker base URL override",
                        "type": "string",
                        "description": "Optional HTTPS Cloud Run override (allowlisted). Production uses Actor env WORKER_BASE_URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
