# Allegro Seller Scraper — Full Catalog + EAN, SKU, Descriptions (`klevio/allegro-seller-scraper`) Actor

Scrape any Allegro.pl or business.allegro.pl seller's full catalog. Two modes: full product data with EAN/SKU/descriptions, or cheap listing-only for price monitoring. Works where other Allegro scrapers fail.

- **URL**: https://apify.com/klevio/allegro-seller-scraper.md
- **Developed by:** [Klevio](https://apify.com/klevio) (community)
- **Categories:** E-commerce, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 listing product scrapeds

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

### What does Allegro Seller Scraper do?

**Allegro Seller Scraper extracts the full product catalog of any seller on Allegro.pl** — Poland's largest e-commerce marketplace with 135M+ active listings. You give the actor a seller URL (e.g. `https://allegro.pl/uzytkownik/BamTrade` or `https://business.allegro.pl/uzytkownik/Natelite-Zoo`) and it returns every product with **URL, name, price, EAN, SKU, description, images, and seller identity** — through pagination, automatically.

This is currently the **only working Allegro scraper on Apify Store** — other scrapers (including official Apify-maintained ones) fail because of Allegro's aggressive DataDome anti-bot protection. We solve it via Bright Data Scraping Browser integration + custom DOM interaction to expand hidden parameter tables where EAN lives.

Try it free with our built-in residential proxy — just paste a seller URL and press Start. The actor runs on the [Apify platform](https://apify.com) which gives you free compute credits, scheduling, API access, and integrations to Google Sheets, Webhook, Slack, and more.

### Why use Allegro Seller Scraper?

**Common use cases:**
- 🏷️ **Price monitoring** — track competitor prices across hundreds of sellers, daily. Repricers, marketplaces, dropshippers
- 🔍 **Competitor product research** — full catalog with EAN/SKU/descriptions for benchmarking
- 📊 **Market intelligence** — spot pricing trends, stock movements, new launches
- 💾 **Catalog import/enrichment** — pull EAN codes to match your own inventory in BaseLinker, Atomstore, Shoper, etc.
- 🤖 **Feed your LLM** — structured product data for AI-powered search, recommendations, product tagging
- 📈 **SEO research** — Allegro product descriptions are a goldmine of long-tail keywords and copywriting patterns

**Why this scraper specifically:**
- ✅ **Actually works** — competing Allegro scrapers on Apify Store are mostly broken (1.0–1.1⭐ reviews from users who got blocked). This one passes DataDome consistently.
- ✅ **Two pricing tiers** — pay only for what you need. Full data at $58/1000 for deep research, or listing-only at $8/1000 for price monitoring (30× cheaper).
- ✅ **Both `allegro.pl` and `business.allegro.pl`** seller URLs supported.
- ✅ **Pagination built-in** — give it a URL of a seller with 5000 products, it'll paginate through all ~83 pages automatically.
- ✅ **EAN extraction** — we programmatically click "Wszystkie parametry" button to unlock hidden parameter tables where EAN/GTIN codes live. Other scrapers miss this.
- ✅ **Resilient** — if the actor is stopped mid-run (budget cap, timeout, user abort), already-scraped products stay in the dataset. You never lose partial work.
- ✅ **Managed proxy** — no need to configure your own proxy. Just press Start.

### How to use Allegro Seller Scraper

1. **Pick your mode:**
   - **Pełny katalog sklepu** (`mode: seller`) — you give a seller URL, we extract the whole catalog
   - **Produkty po URL** (`mode: product`) — you give a list of specific product URLs, we extract details
2. **Choose depth** (for seller mode):
   - `fetchProductDetails: true` → full data including EAN, SKU, description ($58/1000)
   - `fetchProductDetails: false` → fast listing-only for price monitoring ($8/1000)
3. **Paste the URL** (e.g. `https://allegro.pl/uzytkownik/BamTrade`)
4. **Set `maxProducts`** — how many products to extract. `0` = unlimited (whole catalog).
5. **Press Start.** Wait. The actor will log progress and save each product to the Dataset as soon as it's scraped.
6. **Download results** as JSON, CSV, Excel, HTML, or pipe via API into your own system.

### Input

**Minimum input (seller mode, full data):**
```json
{
  "mode": "seller",
  "sellerUrl": "https://allegro.pl/uzytkownik/BamTrade",
  "maxProducts": 100,
  "fetchProductDetails": true
}
````

**Fast price monitoring mode:**

```json
{
  "mode": "seller",
  "sellerUrl": "https://business.allegro.pl/uzytkownik/Natelite-Zoo",
  "maxProducts": 0,
  "fetchProductDetails": false
}
```

**Product-detail-by-URL mode:**

```json
{
  "mode": "product",
  "productUrls": [
    "https://allegro.pl/produkt/telewizor-...-5c3a9ec0?offerId=18138367461",
    "https://allegro.pl/produkt/oczyszczacz-...-e6172171?offerId=15479625845"
  ]
}
```

See the **Input** tab for the full schema with descriptions. All safety knobs are configurable: `maxRequestsPerCrawl` (hard cap), `maxConcurrency`, delays between requests, etc.

#### Power user — bring your own Bright Data

By default the actor uses our managed Bright Data Scraping Browser (price includes proxy). If you have your own Bright Data account, paste your WSS URL in the `brightDataWssUrl` field (secret) and the actor will route through your account — you pay them directly, we charge you less for just the code/compute.

### Output

Each product becomes one row in the Dataset. Example:

```json
{
  "url": "https://allegro.pl/produkt/oczyszczacz-powietrza-toshiba-caf-y92xpl-e6172171-da1a-4b5b-835f-cc86d58b1f3a?offerId=15479625845",
  "name": "Toshiba CAF-Y92XPL Oczyszczacz Powietrza HEPA H13 Węglowy Na Alergię",
  "price": 459,
  "currency": "PLN",
  "ean": "6939924828336",
  "sku": "CAF-Y92XPL",
  "offerId": "15479625845",
  "productId": "e6172171-da1a-4b5b-835f-cc86d58b1f3a",
  "sellerId": "98063506",
  "sellerLogin": "BamTrade",
  "mainImage": "https://a.allegroimg.com/original/1138d5/fd3ff6024b23b9b85ee983ac7e3d/...",
  "images": [
    "https://a.allegroimg.com/original/1138d5/...",
    "https://a.allegroimg.com/original/117b92/..."
  ],
  "description": "Oczyszczacz powietrza Toshiba CAF-Y92XPL z filtrem HEPA H13, technologią jonizacji, pochłaniacz zapachów, cichy pracą ...",
  "scrapedAt": "2026-04-23T00:15:48Z"
}
```

Download as **JSON, CSV, Excel, HTML, RSS, JSONL**, or pipe via Apify API into your own system.

#### Data fields

| Field | Type | Notes |
|---|---|---|
| `url` | string | Canonical product URL |
| `name` | string | Product title (cleaned, no "- Allegro" suffix) |
| `price` | number | Current price (main offer price) |
| `currency` | string | Usually `PLN` |
| `ean` | string | null | EAN (GTIN-13). `null` in listing-only mode or if seller didn't specify. |
| `sku` | string | null | Manufacturer code (Kod producenta). `null` in listing-only mode or if missing. |
| `offerId` | string | Allegro offer ID (unique per listing) |
| `productId` | string | null | Allegro product ID (UUID, shared between offers of the same product) |
| `sellerId` | string | Numeric seller ID |
| `sellerLogin` | string | Seller username (matches URL) |
| `mainImage` | string | null | Highest-resolution main image URL (CDN: allegroimg.com) |
| `images` | string\[] | All product image URLs |
| `description` | string | null | Plain-text product description (HTML stripped, capped at 20K chars). `null` in listing-only mode. |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

### Pricing — how much does it cost to scrape Allegro?

Pay-per-event model — you pay for what's actually scraped:

| Event | Price | When |
|---|---|---|
| Full product scraped | **$0.058** ($58 / 1000) | `fetchProductDetails: true` mode, per product returned with EAN/SKU/description |
| Listing-only product scraped | **$0.008** ($8 / 1000) | `fetchProductDetails: false` mode, per product with URL/name/price only |
| Run start fee | $0.05 | Once per run (covers session init) |

**Example costs:**

- Monitor prices of a 500-product seller daily → $4.05/run → ~$122/month
- Full scrape of a 1000-product seller (one-off) → $58 + start fee = ~$58
- Enrich 100 product URLs with EAN/descriptions → $5.85

**Apify also bills a small compute fee** (included in your Apify plan's free credits for most users — see your Apify Billing dashboard).

### Tips for efficient scraping

- **Use listing-only mode for recurring runs.** If you're monitoring prices daily, you don't need EAN/SKU every time — save 86% vs full mode.
- **Schedule runs in Apify** — free built-in scheduler. "Scrape seller X every 6 hours" is a few clicks.
- **Set `maxProducts: 0`** only if you really want the whole catalog — for most use cases, a capped run (e.g. 500) is faster + cheaper + easier to debug.
- **Increase `minDelayMs`/`maxDelayMs`** if you see 403 errors spike. Default is polite but aggressive; `2000/5000` ms is safer for long runs.
- **For sellers with 5000+ products** — split into multiple runs with `maxProducts: 1000` each, running sequentially. More resilient than one giant run.
- **Combine with Google Sheets integration** — Apify has a native connector. Product data flows directly into your spreadsheet.

### FAQ

**Is scraping Allegro legal?**
Apify and this scraper are tools. Scraping publicly available data (what any browser sees) is generally permitted under EU "sui generis" database rights and by jurisprudence in Poland, but Allegro's [Terms of Service](https://allegro.pl/regulamin/pl) prohibit automated access. Use the actor responsibly: (1) scrape only public data, (2) don't overload Allegro's servers (delays are on by default), (3) ensure GDPR compliance when handling any personal data extracted (e.g. seller names). Consult a lawyer for commercial use cases.

**Why do runs sometimes take a while?**
Full-mode scraping requires visiting each product page individually, including clicking "Wszystkie parametry" to unlock EAN, and waiting for DataDome JS challenge to resolve. Budget ~30 seconds per product for full mode. Listing-only mode is fast: ~10 seconds per 60-product page.

**What if the scraper breaks?**
Allegro's structure changes occasionally. We monitor the actor in production and ship fixes within 24-48h. If you hit a bug, open an Issue on this actor page — we respond to all issues. Your already-scraped data stays safe in the Dataset even if a run fails partway.

**Can I extract reviews / stock / variants / seller ratings?**
Not in the current version, but these are on the roadmap. Priority is driven by user requests — open an Issue if you need a specific field.

**Is GDPR data returned?**
We extract public catalog data. We deliberately don't scrape reviews (which may contain PII) or buyer information. Seller names/IDs are public-facing business identifiers, not personal data.

**What if Allegro blocks my run?**
Our Bright Data integration passes DataDome in 95%+ of cases, verified across multiple sellers including BamTrade, Natelite-Zoo, and official brand stores. If you see persistent 403 errors in your logs, open an Issue — we'll investigate.

**Who maintains this?**
Active solo maintainer. Response time to Issues: <48h (usually same day). Scraper was launched April 2026 and updates are shipped continuously.

### Support & contact

- **Issues tab** — for bug reports, feature requests, questions. Public, so your issue helps other users too.
- **Discord** — [Apify Community](https://discord.com/invite/jyEM2PRvMU) `#scrapers` channel
- **Marketplace listing** — this page

Built with ❤️ for the Polish e-commerce ecosystem.

# Actor input Schema

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

SKLEP SPRZEDAWCY = podajesz URL sprzedawcy/sklepu, scraper zbiera cały katalog z paginacją. PRODUKTY PO URL = podajesz listę konkretnych URL-i produktów, scraper wchodzi w każdy i wyciąga szczegóły.

## `brightDataWssUrl` (type: `string`):

Zostaw PUSTE — domyślnie używamy naszej infrastruktury Bright Data (cena obejmuje proxy i DataDome bypass). Jeśli masz WŁASNE konto Bright Data Browser API i chcesz rozliczać się bezpośrednio z nimi, wklej swój wss://brd-customer-XXX-zone-YYY:PASSWORD@brd.superproxy.io:9222 (znajdziesz w Bright Data Dashboard → Zones → \[zone] → Access Parameters). Pole zaszyfrowane.

## `sellerUrl` (type: `string`):

Pełny URL strony sprzedawcy, np. https://allegro.pl/uzytkownik/BamTrade lub https://business.allegro.pl/uzytkownik/BamTrade. Oba formaty są obsługiwane.

## `productUrls` (type: `array`):

Lista URLi produktów Allegro do scrapowania szczegółów. Akceptowane formaty: allegro.pl/oferta/... oraz allegro.pl/produkt/...

## `maxProducts` (type: `integer`):

Limit dla trybu seller. Ustawienie 0 = bez limitu (cały katalog). Default to bezpieczne 3 — podnieś do 100/1000/10000+ dla prawdziwej pracy.

## `fetchProductDetails` (type: `boolean`):

WŁĄCZONE (zalecane): pełny profil produktu — URL, nazwa, cena, EAN, SKU, opis, zdjęcia. ~30s/produkt, ~$12-15 / 1000 produktów. WYŁĄCZONE (tryb monitoring cen): tylko URL, nazwa, cena, offerId, mainImage. BEZ EAN/SKU/opisu. Błyskawiczne i 30-50× tańsze: ~$0.30-0.50 / 1000. Idealne dla repricera/śledzenia cen konkurencji.

## `maxRequestsPerCrawl` (type: `integer`):

Bezpiecznik — twardy limit requestów w jednym uruchomieniu. Scraper zatrzyma się po tej liczbie niezależnie od maxProducts. Default 5 (1 listing + 3-4 produkty, dobre na test). Dla pracy podnieś do 100-1000+.

## `maxConcurrency` (type: `integer`):

Liczba równoległych sesji browsera. Każda sesja Bright Data zużywa GB. Zalecane 1 na test, 2-3 na produkcji.

## `minDelayMs` (type: `integer`):

Minimalne opóźnienie między requestami w milisekundach. Wyższy delay = mniej podejrzany wzorzec dla DataDome = więcej pełnych stron zamiast challenge.

## `maxDelayMs` (type: `integer`):

Maksymalne opóźnienie między requestami w milisekundach. Scraper losuje wartość pomiędzy min a max dla każdego requestu.

## Actor input object example

```json
{
  "mode": "seller",
  "sellerUrl": "https://allegro.pl/uzytkownik/BamTrade",
  "maxProducts": 3,
  "fetchProductDetails": true,
  "maxRequestsPerCrawl": 5,
  "maxConcurrency": 1,
  "minDelayMs": 1500,
  "maxDelayMs": 4000
}
```

# Actor output Schema

## `products` (type: `string`):

All scraped Allegro products stored in the default dataset. One row per product with url, name, price, EAN, SKU, description, images, and seller info.

# 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 = {
    "sellerUrl": "https://allegro.pl/uzytkownik/BamTrade"
};

// Run the Actor and wait for it to finish
const run = await client.actor("klevio/allegro-seller-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 = { "sellerUrl": "https://allegro.pl/uzytkownik/BamTrade" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Allegro Seller Scraper — Full Catalog + EAN, SKU, Descriptions",
        "description": "Scrape any Allegro.pl or business.allegro.pl seller's full catalog. Two modes: full product data with EAN/SKU/descriptions, or cheap listing-only for price monitoring. Works where other Allegro scrapers fail.",
        "version": "0.1",
        "x-build-id": "yg5Gnrhw0SNYSI30z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/klevio~allegro-seller-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-klevio-allegro-seller-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/klevio~allegro-seller-scraper/runs": {
            "post": {
                "operationId": "runs-sync-klevio-allegro-seller-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/klevio~allegro-seller-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-klevio-allegro-seller-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Tryb działania",
                        "enum": [
                            "seller",
                            "product"
                        ],
                        "type": "string",
                        "description": "SKLEP SPRZEDAWCY = podajesz URL sprzedawcy/sklepu, scraper zbiera cały katalog z paginacją. PRODUKTY PO URL = podajesz listę konkretnych URL-i produktów, scraper wchodzi w każdy i wyciąga szczegóły.",
                        "default": "seller"
                    },
                    "brightDataWssUrl": {
                        "title": "Bright Data WSS URL — OPCJONALNE (tylko dla power users)",
                        "type": "string",
                        "description": "Zostaw PUSTE — domyślnie używamy naszej infrastruktury Bright Data (cena obejmuje proxy i DataDome bypass). Jeśli masz WŁASNE konto Bright Data Browser API i chcesz rozliczać się bezpośrednio z nimi, wklej swój wss://brd-customer-XXX-zone-YYY:PASSWORD@brd.superproxy.io:9222 (znajdziesz w Bright Data Dashboard → Zones → [zone] → Access Parameters). Pole zaszyfrowane."
                    },
                    "sellerUrl": {
                        "title": "URL sklepu (tryb: seller)",
                        "type": "string",
                        "description": "Pełny URL strony sprzedawcy, np. https://allegro.pl/uzytkownik/BamTrade lub https://business.allegro.pl/uzytkownik/BamTrade. Oba formaty są obsługiwane."
                    },
                    "productUrls": {
                        "title": "URL produktów (tryb: product)",
                        "type": "array",
                        "description": "Lista URLi produktów Allegro do scrapowania szczegółów. Akceptowane formaty: allegro.pl/oferta/... oraz allegro.pl/produkt/...",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Maks. liczba produktów",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Limit dla trybu seller. Ustawienie 0 = bez limitu (cały katalog). Default to bezpieczne 3 — podnieś do 100/1000/10000+ dla prawdziwej pracy.",
                        "default": 3
                    },
                    "fetchProductDetails": {
                        "title": "Wchodź w każdy produkt i pobieraj szczegóły (EAN, SKU, opis, zdjęcia)",
                        "type": "boolean",
                        "description": "WŁĄCZONE (zalecane): pełny profil produktu — URL, nazwa, cena, EAN, SKU, opis, zdjęcia. ~30s/produkt, ~$12-15 / 1000 produktów. WYŁĄCZONE (tryb monitoring cen): tylko URL, nazwa, cena, offerId, mainImage. BEZ EAN/SKU/opisu. Błyskawiczne i 30-50× tańsze: ~$0.30-0.50 / 1000. Idealne dla repricera/śledzenia cen konkurencji.",
                        "default": true
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Hard limit requestów na run (safety)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Bezpiecznik — twardy limit requestów w jednym uruchomieniu. Scraper zatrzyma się po tej liczbie niezależnie od maxProducts. Default 5 (1 listing + 3-4 produkty, dobre na test). Dla pracy podnieś do 100-1000+.",
                        "default": 5
                    },
                    "maxConcurrency": {
                        "title": "Równoległość",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Liczba równoległych sesji browsera. Każda sesja Bright Data zużywa GB. Zalecane 1 na test, 2-3 na produkcji.",
                        "default": 1
                    },
                    "minDelayMs": {
                        "title": "Min. opóźnienie (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimalne opóźnienie między requestami w milisekundach. Wyższy delay = mniej podejrzany wzorzec dla DataDome = więcej pełnych stron zamiast challenge.",
                        "default": 1500
                    },
                    "maxDelayMs": {
                        "title": "Max. opóźnienie (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maksymalne opóźnienie między requestami w milisekundach. Scraper losuje wartość pomiędzy min a max dla każdego requestu.",
                        "default": 4000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```