# Allegro Keyword Scraper: Autocomplete & Long-Tail Keywords (`epicscrapers/allegro-keyword-scraper`) Actor

Allegro.pl keyword research without a subscription. Collect the search suggestions shoppers see as they type: long-tail phrases, popular searches, brands and categories. Alphabet expansion, recursive depth, dedup. Export as CSV, Excel, JSON or a plain keyword list.

- **URL**: https://apify.com/epicscrapers/allegro-keyword-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** SEO tools, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 keyword saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

### Allegro Keyword Scraper: autocomplete and long-tail keywords from Allegro.pl

Allegro Keyword Scraper turns Allegro's search box into a keyword list. Give it one or more seed phrases and it collects everything Allegro.pl suggests while a shopper types: long-tail phrases, related searches, brands, car-parts categories and the current popular searches ("Popularne wyszukiwania"). Every keyword comes with its seed, the query that produced it, its position and a ready-to-open Allegro search link.

- **Real Allegro suggestions.** The phrases come straight from Allegro's own autocomplete, the same one shoppers use in the app. Nothing is generated or guessed.
- **50 suggestions per query, not 10.** The search box shows 10 phrases. This actor asks Allegro for its maximum of 50, plus the related-search tiles, so one query returns up to about 60 keywords.
- **Alphabet expansion and depth.** Query `lego a` … `lego z` (and `a lego` … `z lego`, digits, Polish letters) to find long-tail phrases, then optionally expand the results again.
- **Deduplicated across the run.** Each keyword is saved and charged once, however many queries return it.
- **A plain keyword list too.** Besides the table, every run saves `KEYWORDS.txt`, one keyword per line, ready to paste into a listing tool, a spreadsheet or an ads account.
- **Fast and cheap.** About 8,000 keywords per minute. $1 per 1,000 keywords, no subscription, no Allegro account, no proxy setup.

**Słowa kluczowe Allegro:** narzędzie do wyszukiwania fraz kluczowych z podpowiedzi wyszukiwarki Allegro (autouzupełnianie), dla sprzedawców i SEO.

### What can you do with Allegro Keyword Scraper?

| Goal                                 | How                                                                                                                      |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| Write better offer titles            | Collect the phrases shoppers type for your product and use the most specific ones in your Allegro titles and parameters. |
| Find long-tail niches                | Expand a broad seed (`odkurzacz`) with the alphabet and sort by `wordCount` to see specific, lower-competition phrases.  |
| Plan Allegro Ads campaigns           | Export `KEYWORDS.txt` as a keyword list for sponsored offers.                                                            |
| Spot brands and models people search | `brand` rows and phrases such as `iphone 17 pro max` show which brands and models are in demand.                         |
| Watch what Poland is shopping for    | Turn on popular searches and schedule the run; compare the lists over time.                                              |
| Research car-parts demand            | Queries such as `bmw e46 klocki` return parts categories with the matching car model in `vehicle`.                       |
| Feed SEO and content tools           | Use the keywords for category descriptions, blog posts or a product-feed optimization tool.                              |

### How it compares

| What you need                    | Allegro Keyword Scraper                                          | Other Allegro scrapers           | Manual research in the search box |
| -------------------------------- | ---------------------------------------------------------------- | -------------------------------- | --------------------------------- |
| Autocomplete keywords            | Yes, up to ~60 per query                                         | Usually offers only, no keywords | 10 at a time                      |
| Alphabet expansion and depth     | Built in (a–z, prefixes, digits, Polish letters, up to 3 levels) | No                               | Type every letter yourself        |
| Popular searches                 | Yes                                                              | No                               | 5 at a time                       |
| Brands, related tiles, car parts | Labeled by `suggestionType`                                      | No                               | Visible, not exportable           |
| Deduplication                    | Across the whole run                                             | n/a                              | By hand                           |
| Price                            | $1 per 1,000 keywords                                            | Per offer                        | Your time                         |

### Quick start

1. Click **Try for free** and sign in to Apify.
2. Enter one or more **Seed keywords**, for example `lego`.
3. Keep **Alphabet expansion** on "Seed + letter" and set **Max keywords** to `200` for a first run.
4. Click **Start**. The run takes a few seconds. Open the **Output** tab to see the keywords or download `KEYWORDS.txt`.

```json
{
    "keywords": ["lego"],
    "expansion": "alphabet",
    "maxKeywords": 200
}
```

### What data do you get?

Every row is one unique keyword.

| Field            | Description                                                                                                                          |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `keyword`        | The suggested phrase, lowercase, as Allegro searches it.                                                                             |
| `seedKeyword`    | The seed it was found for. `null` for popular searches.                                                                              |
| `sourceQuery`    | The exact query sent (e.g. `lego a`). Empty for popular searches.                                                                    |
| `depth`          | `1` for seed queries, `2`–`3` for expanded results, `0` for popular searches.                                                        |
| `position`       | 1-based position in Allegro's response (related tiles come first, then phrases).                                                     |
| `suggestionType` | `phrase` (autocomplete), `navigation` (related-search tile with a picture), `popular`, `brand` (brand page), `category` (car parts). |
| `wordCount`      | Number of words, handy for sorting long-tail phrases.                                                                                |
| `brandName`      | Brand name for `brand` rows.                                                                                                         |
| `vehicle`        | Car make and model for `category` rows, e.g. `BMW 3 (E46) (1997.12 - 2005.05)`.                                                      |
| `categoryId`     | Allegro category ID, for `category` rows and when you set a category.                                                                |
| `categoryName`   | Allegro category name, e.g. `Zabawki`.                                                                                               |
| `imageUrl`       | Picture of related-search tiles and brand logos. `null` for plain phrases.                                                           |
| `listingUrl`     | Absolute Allegro link that opens this search (or brand or category page).                                                            |
| `scrapedAt`      | When the keyword was collected (ISO 8601, UTC).                                                                                      |

The key-value store record `KEYWORDS.txt` holds the same keywords as a plain list, one per line, in the order they were found.

### Output example

Real rows from the quick-start run (`lego`, October 2, 2026):

```json
[
    {
        "keyword": "lego minecraft",
        "seedKeyword": "lego",
        "sourceQuery": "lego",
        "depth": 1,
        "position": 1,
        "suggestionType": "navigation",
        "wordCount": 2,
        "brandName": null,
        "vehicle": null,
        "categoryId": null,
        "categoryName": null,
        "imageUrl": "https://a.allegroimg.com/s100b/11ea9a/7fbc4c0d4bfc9fa0fd2031691340",
        "listingUrl": "https://allegro.pl/listing?string=lego%20minecraft",
        "scrapedAt": "2026-10-01T22:58:41.720Z"
    },
    {
        "keyword": "kalendarz adwentowy lego marvel",
        "seedKeyword": "lego",
        "sourceQuery": "lego a",
        "depth": 1,
        "position": 30,
        "suggestionType": "phrase",
        "wordCount": 4,
        "brandName": null,
        "vehicle": null,
        "categoryId": null,
        "categoryName": null,
        "imageUrl": null,
        "listingUrl": "https://allegro.pl/listing?string=kalendarz%20adwentowy%20lego%20marvel",
        "scrapedAt": "2026-10-01T22:58:42.316Z"
    },
    {
        "keyword": "karcher",
        "seedKeyword": "odkurzacz",
        "sourceQuery": "odkurzacz k",
        "depth": 1,
        "position": 50,
        "suggestionType": "brand",
        "wordCount": 1,
        "brandName": "Karcher",
        "vehicle": null,
        "categoryId": null,
        "categoryName": null,
        "imageUrl": "https://a.allegroimg.com/original/1287ba/73fcdae44f598756c2f251a8e2ed",
        "listingUrl": "https://allegro.pl/marka/karcher",
        "scrapedAt": "2026-10-01T22:57:33.893Z"
    }
]
```

### Input reference

| Field                  | Type             | Default                     | Effect                                                                                                                   |
| ---------------------- | ---------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `keywords`             | Array of strings | `[]`                        | Seed phrases. An Allegro listing URL with `string=` also works.                                                          |
| `expansion`            | String           | `"alphabet"`                | `"none"`, `"alphabet"` (`lego a` … `lego z`), `"alphabetPrefix"` (`a lego` … `z lego`) or `"both"`.                      |
| `includePolishLetters` | Boolean          | `false`                     | Also expand with ą ć ę ł ń ó ś ź ż. Allegro mostly treats them like plain letters, so this rarely adds keywords.         |
| `includeDigits`        | Boolean          | `false`                     | Also expand with 0–9 (set numbers, sizes, models).                                                                       |
| `depth`                | Integer (1–3)    | `1`                         | `2` also queries every keyword found at depth 1; `3` goes one level further.                                             |
| `maxKeywords`          | Integer          | `1000`                      | Total unique keywords per run. `0` means no limit. You are never charged for more.                                       |
| `suggestionsPerQuery`  | Integer (1–50)   | `50`                        | Phrase suggestions requested per query. The app uses 10; 50 is Allegro's maximum.                                        |
| `onlyContainingSeed`   | Boolean          | `false`                     | Keep only keywords that contain every seed word as a whole word (accents and word order ignored).                        |
| `includePopular`       | Boolean          | `false`                     | Add Allegro's popular searches (about 25–50 per run). Works without seeds.                                               |
| `categoryId`           | String           | Empty                       | Allegro category ID (e.g. `11818`). Adds the category to each row and links to the search inside that category.          |
| `proxyConfiguration`   | Object           | `{ "useApifyProxy": true }` | Proxy settings. The default works; the actor falls back to Polish residential IPs by itself if Allegro blocks a request. |

### Ready-to-run examples

#### Long-tail keywords for one product

```json
{
    "keywords": ["odkurzacz pionowy"],
    "expansion": "both",
    "onlyContainingSeed": true,
    "maxKeywords": 1000
}
```

#### A whole niche, two levels deep

```json
{
    "keywords": ["kawa ziarnista", "ekspres do kawy"],
    "expansion": "alphabet",
    "depth": 2,
    "maxKeywords": 3000
}
```

#### What Poland is searching for right now

```json
{
    "keywords": [],
    "includePopular": true
}
```

Schedule it daily (see below) to build a history of popular searches.

#### Model numbers and sizes

```json
{
    "keywords": ["lego", "opony zimowe"],
    "expansion": "alphabet",
    "includeDigits": true,
    "maxKeywords": 2000
}
```

### Schedule runs and send results anywhere

Save your input as a task, then add it to a schedule in Apify Console (**Schedules → Create new**), for example weekly to follow seasonal phrases. See [Schedules](https://docs.apify.com/platform/schedules). Connect Google Sheets, Make, Zapier or n8n in the task's **Integrations** tab, or fetch the results with the [Apify API](https://docs.apify.com/api/v2). `KEYWORDS.txt` is at `https://api.apify.com/v2/key-value-stores/<storeId>/records/KEYWORDS.txt`.

### Analyze the keywords with ChatGPT or Claude

Download `KEYWORDS.txt` or the CSV and attach it to a chat. Prompts to start with:

- "These are Allegro search suggestions for my product \[describe it]. Group them by buyer intent (model, feature, size, price, gift) and suggest an Allegro offer title of at most 75 characters that covers the most valuable phrases."
- "Find the phrases in this list that name a brand or model number, and list which brands appear most often."
- "Which of these keywords are long-tail (4+ words) and specific enough for a small seller to rank for? Return the 30 best."

### FAQ

#### How many keywords will I get?

One query returns up to about 60 keywords. One seed with alphabet expansion (27 queries) usually gives 500–800 unique keywords; with "both" and digits, around 800. Very specific seeds return fewer. `maxKeywords` caps the total.

#### Does depth 2 or 3 cost more?

You pay per keyword saved, not per request. Deeper levels mostly confirm keywords you already have, so they take longer but add fewer new keywords (in our tests, depth 2 added about 15% more). Use `maxKeywords` to keep runs short.

#### Why does `lego a` return "kalendarz adwentowy lego"?

Allegro's autocomplete matches any word, not only the start of the phrase. These related phrases are often useful. Turn on **Only keywords containing the seed** to keep only phrases that contain your seed words.

#### Are there search volumes?

No. Allegro does not publish search volumes. The order of suggestions (`position`) reflects Allegro's own ranking, which is driven by popularity, so the first phrases are the most searched.

#### Why are Polish letters off by default?

Allegro ignores accents when suggesting: `lego ą` returns the same as `lego a`. Turning them on adds requests but rarely new keywords.

#### Do I need proxies or an Allegro account?

No. The default Apify Proxy works, and the actor retries through Polish residential IPs if a request is blocked. It doesn't log in.

#### How fast is it?

About 13 queries per second, roughly 8,000 keywords per minute. The quick-start run finishes in under 10 seconds.

#### Why did my run stop before reaching my limit?

Either Allegro had no more suggestions for your seeds (try alphabet expansion, digits or depth 2), or the run reached its maximum cost; the log says which. Everything collected is saved.

#### Is it legal to scrape Allegro?

The actor collects public search suggestions only, no personal data. You are responsible for how you use the data, including Allegro's terms and applicable laws such as GDPR.

### Cost

Pay per event, no subscription:

| Event       | Price    | Per 1,000 | Charged when                  |
| ----------- | -------- | --------- | ----------------------------- |
| `keyword`   | $0.001   | $1        | A unique keyword is saved.    |
| Actor start | $0.00005 | –         | Once per run (per GB memory). |

| Run                                              | Cost   |
| ------------------------------------------------ | ------ |
| Quick start (200 keywords)                       | $0.20  |
| One seed, alphabet expansion (~600 keywords)     | ~$0.60 |
| 10 seeds, alphabet expansion, max 5,000 keywords | $5     |
| Popular searches only (~40 keywords)             | ~$0.04 |

Set a maximum cost per run; the actor stops cleanly when it's reached. `KEYWORDS.txt` is free. The **Pricing** tab always shows the current prices.

### Related actors

- [Allegro Reviews Scraper](https://apify.com/epicscrapers/allegro-reviews-scraper): product reviews and ratings from Allegro.pl.
- [Allegro Deals Scraper](https://apify.com/epicscrapers/allegro-deals-scraper): current deals and discounted offers from Allegro.pl.
- [Allegro Keyword Scraper](https://apify.com/epicscrapers/allegro-keyword-scraper): this actor.

### Support

Report problems or request features in the **Issues** tab. Include the run ID, the input and what you expected.

This actor is not affiliated with or endorsed by Allegro.pl sp. z o.o. "Allegro" is a trademark of its owner.

# Actor input Schema

## `keywords` (type: `array`):

Phrases to research, one per entry (e.g. lego, kawa ziarnista). The actor collects what Allegro's search box suggests for each. An Allegro listing URL with a string= parameter also works.

## `expansion` (type: `string`):

Also query each seed with every letter a-z, the way a shopper keeps typing. "Seed + letter" (lego a, lego b, ...) finds long-tail phrases that continue the seed; "Letter + seed" (a lego, b lego, ...) finds phrases where the seed comes later. Each adds 26 requests per seed.

## `includePolishLetters` (type: `boolean`):

Also expand with Polish letters. Allegro mostly treats them like their plain letters (lego ą returns the same as lego a), so this rarely adds keywords.

## `includeDigits` (type: `boolean`):

Also expand with digits, e.g. lego 1 (finds set numbers, sizes, models such as lego 10+, lego 11512).

## `depth` (type: `integer`):

1 queries only the seeds (and their alphabet expansion). 2 also queries every keyword found at depth 1, and 3 goes one level further. Each level multiplies the number of requests; use Max keywords to cap the run.

## `maxKeywords` (type: `integer`):

Stop after this many unique keywords in total. You are never charged for more. Set to 0 for no limit.

## `suggestionsPerQuery` (type: `integer`):

How many phrase suggestions to request per query. The app shows 10; Allegro returns up to 50. Related-search tiles come on top.

## `onlyContainingSeed` (type: `boolean`):

Keep only suggestions that contain every word of their seed as a whole word (ignoring case, word order and Polish accents; other word forms such as kawy for kawa do not match). Off keeps related phrases too, e.g. kalendarz adwentowy for lego a.

## `includePopular` (type: `boolean`):

Also save Allegro's "Popularne wyszukiwania" (popular searches shown for an empty search box). Each of 10 requests returns 5 random popular phrases, about 40-50 unique per run. Works without seed keywords.

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

Optional Allegro category ID (the number at the end of a category URL, e.g. 11818 for allegro.pl/kategoria/zabawki-11818). Rows then get categoryId, categoryName and links to the search inside that category. Allegro suggests the same phrases either way.

## `proxyConfiguration` (type: `object`):

Apify datacenter proxy works for this API. On repeated blocks the actor retries through residential IPs in Poland automatically.

## Actor input object example

```json
{
  "keywords": [
    "lego"
  ],
  "expansion": "alphabet",
  "includePolishLetters": false,
  "includeDigits": false,
  "depth": 1,
  "maxKeywords": 200,
  "suggestionsPerQuery": 50,
  "onlyContainingSeed": false,
  "includePopular": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `keywordList` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "lego"
    ],
    "maxKeywords": 200,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/allegro-keyword-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 = {
    "keywords": ["lego"],
    "maxKeywords": 200,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/allegro-keyword-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 '{
  "keywords": [
    "lego"
  ],
  "maxKeywords": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call epicscrapers/allegro-keyword-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,epicscrapers/allegro-keyword-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/vmYYcATjSMLGnndWf/builds/mMAGZHXzR7D5Nvqlw/openapi.json
