# Allegro Scraper - Products, Prices and Sellers (`lentic_clockss/allegro-scraper`) Actor

Extract Allegro offers, prices, sellers and product details from Poland, Czechia, Slovakia and Hungary. Search keywords, categories or barcodes and pay per delivered row plus a start fee.

- **URL**: https://apify.com/lentic_clockss/allegro-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 25 total users, 7 monthly users, 91.7% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Extract Allegro listings, prices and seller information from Poland, Czechia, Slovakia and Hungary as rows you can export.**

- Search offers, browse categories and compare sellers for a product.
- Look up EAN barcodes and collect optional product details.
- Collect Polish Allegro Lokalnie listings and available Wakacje travel listings.
- Export rows or use them through the Apify API and MCP server.
- Pay $3.00 per 1,000 rows on the Free plan, plus a small start fee.

### What does Allegro Scraper do?

Allegro Scraper collects publicly accessible marketplace data from `allegro.pl`, `allegro.cz`, `allegro.sk` and `allegro.hu`. It is unofficial, is not affiliated with Allegro, and does not place orders or access private accounts.

- **Find offers:** keyword, category, department, seller, barcode and image searches.
- **Compare products:** single offers, product pages and multi-seller offers.
- **Explore:** category nodes, Polish Strefa Okazji deals, Lokalnie and Wakacje.
- **Optional details:** `enrichDetails` is off by default. It adds available attributes to existing rows. In `lokalnie_crawl`, it can also add related offers when room remains; each additional offer is a separate billed row.

### What data can you extract from Allegro?

Fields vary by mode and source availability. `recordType` distinguishes rows; detail enrichment can add fields without changing the original row type.

#### Offer rows: `recordType=offer`

| Field | Description | Example |
| --- | --- | --- |
| `offerId` | Offer identifier | `12345678901` |
| `productId` | Catalog product identifier, when present | `00000000-0000-0000-0000-000000000000` |
| `title` | Listing title | `Mysz bezprzewodowa` |
| `price` | Listed price | `149.99` |
| `currency` | Price currency | `PLN` |
| `url` | Offer link | `https://allegro.pl/oferta/example-12345678901` |
| `country` | Market code | `pl` |
| `seller` | Available seller information | `{"login":"example-shop"}` |
| `promoted` | Promotion flag | `false` |
| `sellingMode` | Sale format | `BUY_NOW` |
| `searchEan` | Barcode used for the search, not proof of a match | `5901234123457` |
| `ean` | Barcode reported by the offer itself | `null` |
| `scrapedAt` | Collection timestamp | `2026-10-24T10:00:00Z` |

#### Detail rows: `recordType=offer_detail`

| Field | Description | Example |
| --- | --- | --- |
| `offerId` | Offer identifier | `12345678901` |
| `title` | Product or offer title | `Mysz bezprzewodowa` |
| `price` | Current price | `149.99` |
| `brand` | Brand shown on the page | `Logitech` |
| `gtin` | Source-reported barcode | `null` |
| `parameters` | Named product attributes | `{"Kolor":"czarny"}` |
| `images` | Available image links | `[]` |
| `rating` | Published rating | `4.8` |
| `reviewCount` | Published review count, not review text | `24` |
| `categoryPath` | Available category names | `["Elektronika"]` |
| `location` | Lokalnie location, when shown | `{"city":"Warszawa"}` |

#### Category rows: `recordType=category`

| Field | Description | Example |
| --- | --- | --- |
| `nodeType` | Department or leaf category | `leaf` |
| `categoryId` | Numeric category identifier | `257228` |
| `departmentCode` | Department identifier | `elektronika` |
| `name` | Category name | `Smartfony i telefony komórkowe` |
| `slug` | Category URL text | `smartfony-i-telefony-komorkowe` |
| `path` | Category path names | `["Elektronika"]` |
| `url` | Category link | `https://allegro.pl/kategoria/smartfony-i-telefony-komorkowe-257228` |

#### Travel rows: `recordType=travel`

| Field | Description | Example |
| --- | --- | --- |
| `title` | Travel listing title | `Weekend nad morzem` |
| `url` | Listing link | `https://wakacje.allegro.pl/example` |
| `price` | Displayed price, if available | `499` |
| `currency` | Displayed currency | `PLN` |
| `country` | Market code | `pl` |
| `domain` | Source domain | `wakacje.allegro.pl` |

### How to scrape Allegro

1. Open [Allegro Scraper](https://apify.com/lentic_clockss/allegro-scraper) in Apify Console.
2. Fill one target field, such as `query`, and choose your `country`.
3. Set `maxResults` to `3` for a small first run.
4. Click **Start** and wait for completion.
5. Open the dataset and download the rows.

Empty input runs the form's example: `query=iphone`, `country=pl`, at most 3 rows. Normal start and row charges apply. With `mode=auto`, one target field selects the matching mode. URLs take priority over IDs, then keywords, then city; inspect `INPUT_REPORT` when mixing targets.

#### Automatic selection

Use `startUrls` for existing listing or detail links. A URL's market overrides the country selection.

#### Keyword search

Use `query` or `searchQueries` with `mode=search`.

#### Category listing

Use `categoryId` or `categoryIds` with `mode=category`; supply `categorySlug` when known.

#### Category tree

Choose `mode=categories` without a target to collect category nodes, not offers.

#### Department

Use `departmentCode` with `mode=department`.

#### Deals

Choose `mode=deals` for Polish Strefa Okazji offers; no target is required.

#### Product page

Use `productId` with `mode=product` for a catalog product page.

#### Product offers

Use `productId` with `mode=product_offers` to compare available seller offers.

#### Single offer

Use `offerId` with `mode=offer` for an individual offer.

#### Seller storefront

Use `sellerLogin` with `mode=seller`; optionally restrict it with `categoryId`.

#### Lokalnie search

Choose `mode=lokalnie` with `query` or `city`. This uses the Polish marketplace.

#### Lokalnie discovery

Choose `mode=lokalnie_crawl` to discover local offers. A target is optional; the row limit still applies.

#### Allegro API search

`mode=allegro_api` accepts a keyword, but requires publisher-enabled Allegro API access. Availability is not guaranteed; prefer `search` for ordinary runs.

#### EAN lookup

Use `eans` or `ean` with `mode=ean`; codes must contain 8–14 digits. Search results can include near matches.

#### Image search

Use a public `imageUrl` with `mode=image_search`. It can fail when image upload is unavailable.

#### Wakacje

Choose `mode=wakacje`, optionally with `query`, for available Polish travel listings. Coverage depends on accessible listings.

### What to fill in

| Field | What to enter | Default |
| --- | --- | --- |
| `mode` | A mode described above | `auto` |
| `query` | One search keyword | Empty; form prefill `iphone` |
| `searchQueries` | Several keywords | Empty |
| `startUrls` | URLs, or objects with a `url` field | Empty |
| `country` | `pl`, `cz`, `sk`, `hu` | `pl` |
| `domain` | Matching Allegro domain | `allegro.pl` |
| `maxResults` | Maximum rows per input, from 1 to 500 | `70`; form prefill `3` |
| `categoryId`, `categoryIds` | One category ID or several | Empty |
| `categorySlug` | Category URL slug | Empty |
| `departmentCode` | Department, such as `elektronika` | Empty |
| `productId` | Catalog product UUID | Empty |
| `offerId` | Numeric offer ID | Empty |
| `sellerLogin` | Storefront login | Empty |
| `ean`, `eans` | One barcode or a list | Empty |
| `imageUrl` | Public image URL | Empty |
| `city` | Lokalnie city, such as `warszawa` | Empty |
| `order` | `m` relevance, `p` price ascending, `pd` descending, `d` price with delivery, `n` newest, `qd` popularity | `m` |
| `p` | Starting category page | `1` |
| `priceFrom`, `priceTo` | Price bounds in the market's currency | Unset |
| `condition` | Site condition filter | Empty |
| `buyNow` | Restrict to buy-now offers | Unset |
| `freeShipping` | Restrict to free shipping | Unset |
| `offerType` | Site offer-type filter | Empty |
| `seller` | Seller login filter for listings | Empty |
| `enrichDetails` | Add available details | `false` |
| `scrapeProductDetails` | Alternative switch for detail enrichment | `false` |

Examples below request three rows at most per input. Replace example IDs, seller logins and image URLs with real targets.

Automatic URL selection:

```json
{"mode":"auto","startUrls":["https://allegro.pl/listing?string=rower"],"maxResults":3}
```

Keyword search:

```json
{"mode":"search","query":"rower","country":"pl","maxResults":3}
```

Category listing:

```json
{"mode":"category","categoryId":"257228","categorySlug":"smartfony-i-telefony-komorkowe","maxResults":3}
```

Category tree:

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

Department:

```json
{"mode":"department","departmentCode":"elektronika","maxResults":3}
```

Deals:

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

Product page:

```json
{"mode":"product","productId":"00000000-0000-0000-0000-000000000000","maxResults":3}
```

Product offers:

```json
{"mode":"product_offers","productId":"00000000-0000-0000-0000-000000000000","maxResults":3}
```

Single offer:

```json
{"mode":"offer","offerId":"12345678901","maxResults":3}
```

Seller storefront:

```json
{"mode":"seller","sellerLogin":"example-shop","maxResults":3}
```

Lokalnie search:

```json
{"mode":"lokalnie","query":"rower","maxResults":3}
```

Lokalnie discovery:

```json
{"mode":"lokalnie_crawl","maxResults":3}
```

Allegro API search, when available:

```json
{"mode":"allegro_api","query":"rower","maxResults":3}
```

EAN lookup:

```json
{"mode":"ean","eans":["5901234123457"],"enrichDetails":true,"maxResults":3}
```

Image search:

```json
{"mode":"image_search","imageUrl":"https://example.com/product.jpg","maxResults":3}
```

Wakacje:

```json
{"mode":"wakacje","query":"morze","maxResults":3}
```

`maxItems` and `limit` are accepted as aliases for `maxResults`. Close field-name misspellings are corrected; other unknown fields are ignored with a note. Every run writes the interpretation to `INPUT_REPORT` in its default key-value store. Invalid filters can fall back to defaults. Unresolvable input produces `INVALID_INPUT: <field> — <how to fix>` before rows are charged; later field validation may use a different error message.

### Output example

Illustrative offer row; fields are not guaranteed on every listing:

```json
{
  "recordType": "offer",
  "offerId": "12345678901",
  "title": "Mysz bezprzewodowa",
  "price": 149.99,
  "currency": "PLN",
  "url": "https://allegro.pl/oferta/example-12345678901",
  "domain": "allegro.pl",
  "country": "pl",
  "seller": {"login": "example-shop"},
  "promoted": false,
  "sellingMode": "BUY_NOW",
  "scrapedAt": "2026-10-24T10:00:00Z"
}
```

Export the dataset as JSON, CSV, Excel, XML, RSS or an HTML table. Nested attributes are easiest to inspect in JSON.

### Why use this Allegro scraper?

- **Row-based billing:** row charges apply to delivered rows, not unsuccessful page attempts.
- **Retained output:** rows already written remain available after a stop. Delivery of unfinished collection is not guaranteed.
- **Understandable failures:** inspect `ERROR_SUMMARY` for failures and `RUN_SUMMARY` for completed runs.
- **Source-based fields:** unavailable attributes stay empty rather than being guessed.
- **Several inputs:** submit keyword, category, barcode or URL lists in one run.
- **No proxy setup:** you do not need to set up proxies.

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

The Actor uses pay-per-event pricing. Platform usage is included in these prices.

| Apify plan | Start event | Price per row | Price per 1,000 rows |
| --- | --- | --- | --- |
| Free | $0.005 | $0.003 | $3.00 |
| Starter | $0.005 | $0.003 | $3.00 |
| Scale | $0.005 | $0.0026 | $2.60 |
| Business | $0.005 | $0.0022 | $2.20 |
| Platinum | $0.005 | $0.0020 | $2.00 |
| Diamond | $0.005 | $0.0016 | $1.60 |

Start events are charged per GB of allocated memory, with a minimum of one event. The default 512 MB run therefore incurs one $0.005 start event.

`maxResults` applies to each input, defaults to 70 and accepts up to 500. Larger requests are collected in parts. All row types count together. Free Apify plan runs are capped at 200 rows, with 10 runs of this Actor. The whole run is constrained by **Maximum cost per run** (`maxTotalChargeUsd` in the API).

Example: three keywords delivering five rows each produce 15 rows. On the Free plan at 512 MB, one start plus those rows costs $0.005 + 15 × $0.003 = **$0.050**. Fewer delivered rows mean fewer row charges; the start event still applies.

- The Apify Free plan includes **$5.00** in monthly usage credit (about **1,666 rows** at `$0.003` per row across Free-plan runs capped at 200 rows per run).

### What happens when the run timeout is too short

When automatic resumption is accepted, a run that cannot wait long enough can pause rather than fail. Its status message says "Queued on the collection backend; this run will resume automatically when results are ready (about N s)." It temporarily appears as `ABORTED`.

When results are ready, the same run resumes, reports "Resumed: delivering N rows.", writes to the same dataset and finishes as `SUCCEEDED` if delivery succeeds. Saved delivery progress prevents rows being delivered or charged twice. No manual restart is needed for this pause.

- Automatic pausing is limited to 3 attempts per run. Keep the default timeout of 3600 seconds to reduce pauses.
- Resumption is not a guarantee against collection failures or every timeout.
- Synchronous API endpoints (`run-sync`, `run-sync-get-dataset-items`) wait at most 300 seconds and can return an empty dataset during a pause. For larger requests, start asynchronously and read rows after `SUCCEEDED`, or use a succeeded-event webhook.

### Use with AI agents and the API

#### Apify MCP server

Add this remote server to Claude, ChatGPT, Cursor, VS Code or another compatible MCP client:

```text
https://mcp.apify.com?tools=lentic_clockss/allegro-scraper
```

Sign in with Apify using OAuth, or send `Authorization: Bearer <YOUR_APIFY_TOKEN>`. The tool starts a run and returns run and dataset IDs; read rows with `get-dataset-items`. Clients without remote support can use `npx @apify/actors-mcp-server --tools lentic_clockss/allegro-scraper` with `APIFY_TOKEN` set.

Example prompt: "Find three bicycle offers on Allegro Poland using `query=rower` and `maxResults=3`, then show their titles, prices and links."

- **Agent execution note:** Set `maxResults` between `5` and `20` on exploratory tool calls to keep responses compact, and read `RUN_SUMMARY` and `INPUT_REPORT` from the default key-value store to inspect normalized inputs and delivered row counts. When a long run briefly reports `ABORTED` with the automatic-resume status message, wait for the same run ID to finish as `SUCCEEDED` instead of starting a duplicate run.

#### Apify API

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lentic_clockss/allegro-scraper").call(
    run_input={"query": "rower", "country": "pl", "maxResults": 3}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('lentic_clockss/allegro-scraper').call({
  query: 'rower', country: 'pl', maxResults: 3
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

For asynchronous HTTP calls, send input JSON to `POST https://api.apify.com/v2/acts/lentic_clockss~allegro-scraper/runs` with an `Authorization: Bearer` header. Read the output using `GET https://api.apify.com/v2/datasets/<datasetId>/items?format=json` after completion.

#### Integrations

Use the **Integrations** tab for Google Sheets, Make, Zapier, n8n, Slack, Airtable or webhooks. Apify Schedules can repeat saved inputs for price monitoring.

### Po polsku

Allegro Scraper zbiera publicznie dostępne oferty, ceny, waluty i informacje o sprzedawcach. Obsługuje rynki polski, czeski, słowacki i węgierski. Aby zacząć, wpisz frazę w `query`, wybierz `country` i ustaw `maxResults` na 3. Gotowe adresy stron możesz podać w `startUrls`, a kody kreskowe w `eans`. Wyniki pobierzesz jako JSON, CSV lub Excel. Opłata obejmuje uruchomienie oraz każdy dostarczony wiersz; brakujące dane nie są uzupełniane domysłami. Opcja `enrichDetails` dodaje dostępne szczegóły produktu, ale może wydłużyć pracę. Wyszukiwanie po kodzie EAN może zwrócić podobne produkty, dlatego porównuj `searchEan` z odczytanym `ean`. Narzędzie nie składa zamówień i nie udostępnia prywatnych danych kontaktowych z Allegro Lokalnie.

### FAQ

#### Is it legal to scrape Allegro?

Use public data responsibly. You are responsible for complying with Allegro's terms and applicable data-protection law; processing personal data requires a lawful basis.

#### Why did my run end as ABORTED?

An automatic pause can temporarily show `ABORTED`; read the status message before restarting. Manual cancellation is different and does not promise automatic completion.

#### How many results can I get?

Request 1–500 rows per input. Actual output depends on available matches, the run's charge ceiling and free-plan limits. This is not a full-market export guarantee.

#### Why are some fields empty?

The page may omit them, or detail collection may not finish. Lokalnie contact fields remain `null`; login-only phone numbers and emails are not provided.

#### Is this an official Allegro API?

No. This is an independent Actor, not an Allegro product or an endorsed service.

#### Which countries are supported?

The main marketplaces support `pl`, `cz`, `sk` and `hu`. Lokalnie and Wakacje use Polish domains; Strefa Okazji deals are Poland-specific.

#### Does EAN lookup guarantee an exact barcode match?

No. `searchEan` is the searched code. Enable `enrichDetails` and compare it with the source-reported `ean` when available; ads and near matches can appear.

#### What does detail enrichment change?

It adds available brand, barcode, attributes, images and other details. Main-market listing enrichment is limited to up to 20 offers per collection part; Lokalnie details follow the requested row budget. Neither guarantees every field.

### Limitations

- Only the listed marketplaces and modes are supported; private accounts and checkout are outside scope.
- Site restrictions can prevent collection. No success rate or complete catalog coverage is promised.
- Image search, Wakacje and Allegro API search depend on feature availability.
- Filters vary by page and market; a supplied filter is not proof every returned offer matches it.
- Category output includes department entries and discovered categories, not a guaranteed complete hierarchy.
- Review counts do not include review text. Related offers share the row limit and are billed separately.

### Related scrapers

More e-commerce and marketplace scrapers from the same publisher:

- [Walmart Scraper](https://apify.com/lentic_clockss/walmart-scraper)
- [Temu Scraper](https://apify.com/lentic_clockss/temu-scraper)
- [Shopee Scraper](https://apify.com/lentic_clockss/shopee-search-scraper)
- [Amazon Scraper](https://apify.com/lentic_clockss/amazon-search-results-collector)
- [Rakuten Scraper](https://apify.com/lentic_clockss/rakuten-scraper)
- [TikTok Shop Scraper](https://apify.com/lentic_clockss/tiktok-shop-scraper)
- [Stealth Web Scraper](https://apify.com/lentic_clockss/stealth-web-scraper)
- [Email Validator](https://apify.com/lentic_clockss/email-risk-validator)

Browse all of our scrapers at [apify.com/lentic_clockss](https://apify.com/lentic_clockss).

### Support

Report a problem or request a field through the **Issues** tab of this Actor's page. Include the run ID and the input you used.

# Actor input Schema

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

Choose Auto to select a mode from your target fields, or choose a specific mode below. Some modes depend on feature availability.

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

Enter Allegro page URLs as strings or objects with a url field. The URL determines the market.

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

Enter one keyword for search, Lokalnie, Allegro API search or Wakacje. With Auto selected, this field starts a keyword search.

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

Optional list of keywords. Each keyword is collected separately, up to maxResults rows for each keyword; every row is charged.

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

Enter the numeric category ID from an Allegro category URL.

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

Optional list of category IDs. Each category is collected separately, up to maxResults rows for each category; every row is charged.

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

Enter the catalog product UUID from an Allegro product URL.

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

Enter the numeric identifier of a single-seller offer.

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

Enter the seller login used in the storefront URL.

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

Enter 8–14 digit EAN or GTIN barcodes for EAN lookup. Results may include near matches; keywords belong in search mode.

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

Enter one EAN barcode instead of the eans list.

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

Enter a publicly accessible HTTP or HTTPS image URL for image search. The run can fail if image upload is unavailable.

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

Enter a department code, such as elektronika or moda, for department mode.

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

Enter a city for Lokalnie, such as warszawa.

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

Maximum rows for each keyword, URL, category, barcode or other target, from 1 to 500; default 70. All row types share the limit, with the whole run constrained by your maximum charge and Free plan limits of 200 rows per run and 10 runs.

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

Choose the main Allegro market: Poland, Czechia, Slovakia or Hungary.

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

Choose the matching Allegro domain. A supplied page URL takes priority; Lokalnie and Wakacje use their Polish domains.

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

Enter the text part of the category URL when known, for category or seller-category listings.

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

Choose relevance, price ascending, price descending, price with delivery, newest or popularity. Availability varies by page.

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

Enter the starting category page number, from 1 to 500.

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

Add available brand, barcode, attributes, images and other offer details. This is optional and may take longer; in Lokalnie discovery it can also add separately billed related offers within the row limit.

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

Alternative switch for enrichDetails. Enabling either switch requests available product details.

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

Minimum offer price in the selected market currency, where the page supports this filter.

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

Maximum offer price in the selected market currency, where the page supports this filter.

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

Enter the site condition value, such as new or used, where supported.

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

Request buy-now offers only, where supported.

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

Request offers with free shipping, where supported.

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

Enter the offer-type filter used by the selected page.

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

Enter a seller login to filter listing results, where supported.

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

Leave empty. Used only by the developer for testing.

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

Leave empty. Used only by the developer for testing.

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

Leave empty. Used only by the developer for testing.

## Actor input object example

```json
{
  "mode": "auto",
  "query": "iphone",
  "maxResults": 3,
  "country": "pl",
  "domain": "allegro.pl",
  "order": "m",
  "p": 1,
  "enrichDetails": false,
  "scrapeProductDetails": false
}
```

# Actor output Schema

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

Allegro offer, detail, category or travel rows from the default dataset.

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

Run summary, including the delivered row count and completion information.

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

The interpreted input saved for the run.

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

Failure details, when an error summary was saved.

# 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 = {
    "mode": "auto",
    "query": "iphone",
    "maxResults": 3,
    "country": "pl",
    "domain": "allegro.pl"
};

// 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 = {
    "mode": "auto",
    "query": "iphone",
    "maxResults": 3,
    "country": "pl",
    "domain": "allegro.pl",
}

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "auto",
  "query": "iphone",
  "maxResults": 3,
  "country": "pl",
  "domain": "allegro.pl"
}' |
apify call lentic_clockss/allegro-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lentic_clockss/allegro-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/efJTXufnvug2PQUPm/builds/70qPgsEs8GJCO4lRZ/openapi.json