Allegro Data API: Extract Structured JSON in 2026

This guide covers extracting publicly accessible data. Always review a site's robots.txt and Terms of Service before scraping.

TL;DR

Use AlterLab’s Extract API to POST a URL and a JSON schema. The service returns typed JSON for fields like title, price, currency, SKU and availability from Allegro pages. No HTML parsing, no fragile selectors—just structured data ready for your pipeline.

Why use Allegro data?

Allegro is one of Europe’s largest marketplaces, hosting millions of product listings. Engineers pull this data for:

• Training price‑prediction models that need recent, real‑world examples.
• Building analytics dashboards that track category trends over time.
• Enabling competitive intelligence pipelines that monitor SKU availability and promotions.

What data can you extract?

From a typical Allegro product page you can request:

• title – the product name as displayed.
• price – the current sale price.
• currency – the three‑letter ISO code (PLN, EUR, etc.).
• sku – the seller’s stock‑keeping unit.
• availability – in‑stock, out‑of‑stock or pre‑order status.
• rating – average user rating when present. All fields are returned as strings; you can cast them downstream if needed.

The extraction approach

Raw HTTP requests followed by HTML parsing break whenever Allegro updates its markup. Selectors become stale, anti‑bot measures trigger CAPTCHAs, and you spend time maintaining fragile code. A data API abstracts those concerns:

• Automatic proxy rotation and JavaScript rendering handle anti‑bot challenges.
• The Extract API validates output against your schema, guaranteeing typed JSON.
• You focus on the data model, not on page‑specific scraping logic.

Quick start with AlterLab Extract API

First, install the Python client from the Getting started guide. Then call the extract endpoint with a URL and a schema.

from alterlab import AlterLabSync

client = AlterLabSync("YOUR_API_KEY")

schema = {
  "type": "object",
  "properties": {
    "title": {
      "type": "string",
      "description": "The product title"
    },
    "price": {
      "type": "string",
      "description": "The price value"
    },
    "currency": {
      "type": "string",
      "description": "The currency code (e.g. PLN)"
    },
    "sku": {
      "type": "string",
      "description": "The seller SKU"
    },
    "availability": {
      "type": "string",
      "description": "Stock status"
    },
    "rating": {
      "type": "string",
      "description": "Average rating"
    }
  }
}

result = client.scrape(
    url="https://allegro.pl/oferta/przykładowy-produkt-123456789",
    extraction_schema=schema,
)
print(result["filtered_content"])

The same request works with cURL:

curl -X POST https://api.alterlab.io/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://allegro.pl/oferta/przykładowy-produkt-123456789",
    "schema": {
      "properties": {
        "title": {"type": "string"},
        "price": {"type": "string"},
        "currency": {"type": "string"},
        "sku": {"type": "string"},
        "availability": {"type": "string"},
        "rating": {"type": "string"}
      }
    }
  }'

Both examples return a JSON object matching the schema, ready for ingestion into your data warehouse or ML pipeline.

Define your schema

The Extract API uses JSON Schema to describe the shape of the output. You declare each field’s type, format and optional constraints. AlterLab validates the extracted content against this schema before returning it, so you never receive a field with the wrong type or missing key. If a field cannot be found, the API returns null for that property, preserving the schema’s structure.

Example schema with constraints:

{
  "type": "object",
  "properties": {
    "title": {"type": "string", "minLength": 1},
    "price": {"type": "string", "pattern": "^[0-9]+\\.[0-9]{2}$"},
    "currency": {"type": "string", "enum": ["PLN", "EUR", "USD"]},
    "sku": {"type": "string", "maxLength": 50},
    "availability": {"type": "string", "enum": ["in_stock", "out_of_stock", "preorder"]},
    "rating": {"type": "string", "pattern": "^[0-9](\\.[0-9])?$"}
  },
  "required": ["title", "price", "currency"]
}

Supplying such a schema ensures downstream consumers can rely on consistent data contracts.

Handle pagination and scale

For bulk extraction you’ll often need to iterate over search results or category pages. AlterLab supports asynchronous jobs and batch endpoints to stay within rate limits.

from alterlab import AlterLab
import asyncio

client = AlterLab("YOUR_API_KEY")

urls = [
    f"https://allegro.pl/listing?string=laptop&p={i}"
    for i in range(1, 21)  # first 20 pages
]

async def extract_all():
    tasks = [
        client.scrape(url=url, extraction_schema=schema)
        for url in urls
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        print(resp.data)

asyncio.run(extract_all())

The asynchronous client fires requests in parallel while respecting the concurrency limits you set in your dashboard. For very high volume, consider using the batch endpoint which accepts an array of URLs and returns an array of results in a single HTTP call—see the Extract API docs for payload details.

Cost scales linearly with the number of successful extractions. Check the AlterLab pricing page for per‑call rates and volume discounts.

Key takeaways

• AlterLab’s Extract API turns any public Allegro page into typed JSON with a single POST.
• Define a JSON schema once and receive validated data every time—no parsing, no selector maintenance.
• The service handles proxies, JavaScript rendering and anti‑bot challenges so your pipeline stays reliable.
• Start with a single URL, iterate to batches, and pay only for what you use.