# Polish Jobs Aggregator: Pracuj.pl, OLX, JustJoin & 7 more (`tsutseisoftware/polish-jobs-aggregator`) Actor

Ten Polish job boards in one run: Pracuj.pl, OLX Praca, Praca.gov.pl, Praca.pl, RocketJobs, Aplikuj, InfoPraca, JustJoin.it, NoFluffJobs, theprotocol. Duplicates merged, salary, monitoring, market summary. Oferty pracy w jednym miejscu.

- **URL**: https://apify.com/tsutseisoftware/polish-jobs-aggregator.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.08 / 1,000 job (aggregation)s

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

## Polish Jobs Aggregator: Pracuj.pl, OLX, Praca.gov.pl & 7 More

Get the jobs of **ten Polish job boards in one run**: **Pracuj.pl**, **OLX Praca**, **Praca.gov.pl** (all labour office offers, CBOP), **Praca.pl**, **RocketJobs.pl**, **Aplikuj.pl**, **InfoPraca.pl** and the IT boards **JustJoin.it**, **NoFluffJobs** and **theprotocol.it**. Pick the portals, type your search once (keywords, towns with a distance, voivodeships, work mode including remote, minimum salary, contract type such as UoP, B2B or zlecenie, position level, posting date) and get **one row per job**: the same job found on several portals is **merged into one row** with all its portals and links. Every row has the same fields whatever the portal: title, company, town, voivodeship, GPS, salary as numbers with monthly and hourly equivalents and its kind (gross, or net + VAT for B2B), Polish contract types, work mode, position level, dates, and with details the description.

Built for **recruiters, staffing agencies, HR and salary analysts, job boards and job seekers with a narrow field** who watch the Polish labour market: schedule it daily in **monitoring mode** and you get (and pay the full price for) only the jobs that are new or changed on any portal, optionally also the jobs that **disappeared from every portal**, with a **notification to Telegram, Slack, Discord, WhatsApp or your webhook**. Every run also saves a free **market summary** (salary quartiles by portal, voivodeship, town, category, contract type and level, top employers).

> **Po polsku:** Oferty pracy z **dziesięciu polskich portali w jednym uruchomieniu**: Pracuj.pl, OLX Praca, Praca.gov.pl (Centralna Baza Ofert Pracy, oferty urzędów pracy), Praca.pl, RocketJobs.pl, Aplikuj.pl, InfoPraca.pl oraz portale IT JustJoin.it, NoFluffJobs i theprotocol.it. Wyszukiwanie raz: słowa kluczowe, miasta z promieniem (np. praca w Warszawie, Krakowie, Wrocławiu), województwa, praca zdalna lub hybrydowa, minimalne wynagrodzenie, rodzaj umowy (umowa o pracę, B2B, umowa zlecenie), poziom stanowiska i data publikacji. **Jedna oferta z kilku portali to jeden wiersz** z linkami do wszystkich ogłoszeń. Wynagrodzenie (widełki) miesięcznie i godzinowo, brutto lub netto + VAT, filtr pracy zmianowej, monitoring nowych i usuniętych ofert, powiadomienia w Telegramie, Slacku, Discordzie i WhatsAppie oraz podsumowanie rynku pracy. Proxy w cenie. Eksport do Excela, CSV lub JSON.

### Why use this Polish jobs aggregator?

- 🧭 **Ten Polish job boards at once**, more than any other Apify actor: the general boards (Pracuj.pl, OLX, labour offices, Praca.pl, RocketJobs.pl, Aplikuj.pl, InfoPraca.pl) and the IT boards (JustJoin.it, NoFluffJobs, theprotocol.it). Each portal is read with the same filters and data quality as our dedicated actor for it.
- 🔗 **Duplicates merged.** Employers and agencies post the same job on several boards. The same job is **one row** with `portals` and `sources` (every ad with its link), and you pay for it once, at the price of its cheapest portal.
- 🎯 **One search, every portal's own filters.** Towns with a distance, voivodeships, remote or hybrid work, minimum salary, contract types (UoP, B2B, zlecenie, o dzieło), position level and posting date are translated to each portal's own filters. A portal that cannot apply a filter you set is not read, rather than returning jobs that do not match (the status message says so).
- 🔎 **Filters no portal has:** keep only jobs that **mention** your terms in the title, company, category or description, leave out jobs mentioning others (`staż`, `agencja pracy`), **no shift work** (two or three shifts, night shifts), **only the towns themselves** (not the commuter belt).
- 📋 **One schema for all portals.** Salary as numbers (`salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryKind`) with **monthly and hourly equivalents**, town, voivodeship and GPS, Polish contract types, work mode, level on one scale, shift work, dates, apply link, description with details.
- 🏛️ **All labour office offers included.** Praca.gov.pl (CBOP, every offer with a gross salary, with the contact the office publishes) is a source like the others.
- 📬 **Monitoring across portals:** a daily feed of jobs that are new or changed on any portal, and of jobs that disappeared from every portal that had them.
- 🔔 **Notifications** to Telegram, Slack, Discord, WhatsApp or any webhook after each run ($0.001 per run that sent one).
- 📊 **Free market summary** (`SUMMARY`): monthly salary quartiles in PLN split into gross and B2B, by portal, voivodeship, town, category, contract type and level; top employers; work modes; and per portal the jobs read, saved and why some were left out.
- 🤖 **Output for AI agents and spreadsheets:** compact output with the core fields, the description as plain text, Markdown or HTML, and extra exports (a printable HTML report or a Markdown table), besides Excel, CSV and JSON.
- 💸 **No extra platform costs:** platform usage and the residential proxy Pracuj.pl needs are included in the price.

### Portals

| Portal | `sources` value | Price per 1 000 jobs | Job page (with details) | Notes |
|---|---|---|---|---|
| Pracuj.pl | `pracuj` | $0.94 | +$0.39 | the biggest Polish job board; residential proxy included |
| OLX Praca | `olx-praca` | $1.19 | included | local and blue-collar jobs, with the full ad text and its job data |
| Praca.gov.pl (labour offices, CBOP) | `praca-gov-pl` | $1.19 | +$0.20 | all labour office offers, always with a gross salary and the published contact |
| Praca.pl | `praca-pl` | $1.08 | +$0.35 | one of the oldest Polish job boards |
| RocketJobs.pl | `rocketjobs` | $0.80 | +$0.15 | sales, marketing, logistics, finance and other non-IT jobs |
| Aplikuj.pl | `aplikuj` | $0.36 | +$1.25 | large general board |
| InfoPraca.pl | `infopraca` | $0.89 | +$0.25 | general board, many jobs abroad |
| JustJoin.it | `justjoin` | $0.56 | +$0.15 | IT |
| NoFluffJobs | `nofluffjobs` | $0.59 | +$0.05 | IT, always with a salary range |
| theprotocol.it | `theprotocol` | $0.84 | +$0.10 | IT |

By default the actor reads the seven general boards; JustJoin.it, NoFluffJobs and theprotocol.it are read when you pick them (for a warehouse or driver search the IT boards only add noise). Portals are read in parallel, each at its own polite rate (portals of one operator one after another), up to **Max jobs per portal** (by default its share of **Max jobs**: Max jobs ÷ number of portals + 20 %).

### How to scrape all Polish job boards

1. Choose the **Job portals** (or keep the seven general ones).
2. Type **Search terms** (e.g. `magazynier`, `kierowca`, `księgowa`, `python`) and optionally **Towns** with a **Distance**, or **Voivodeships**.
3. Add filters: **Work mode** (remote, hybrid, on site), **Minimum monthly salary (PLN)**, **Contract types**, **Position level**, **Posted within days**, **Keep only jobs mentioning**, **No shift work**.
4. Set **Max jobs** (saved jobs after merging) and **Max jobs per portal**.
5. Run it and download the dataset as Excel, CSV or JSON, or schedule it daily with **Monitoring: only new or changed jobs** and a notification.

### Use cases

#### New warehouse jobs around Warsaw in Telegram every morning

Save the input as a task with a daily **Schedule**. Each run saves (and charges in full) only the jobs that are new or changed on any portal, and sends them to your Telegram chat; a morning without news sends nothing.

```json
{
  "searchQueries": ["magazynier", "operator wózka widłowego"],
  "locations": ["Warszawa"],
  "radiusKm": 30,
  "maxItems": 300,
  "onlyNewOrChanged": true,
  "monitoringKey": "magazyn-warszawa",
  "telegramBotToken": "123456:ABC…",
  "telegramChatId": "-1001234567890"
}
```

#### A niche watch: lab jobs near Kraków, no shift work

Several search terms, the full-text filter for the field, without shift work and without the nearby towns:

```json
{
  "searchQueries": ["technolog", "laborant", "chemik", "kontrola jakości"],
  "locations": ["Kraków"],
  "includeTerms": ["chemi", "laborator", "technolog", "kontrola jakości"],
  "excludeTerms": ["praktyki", "staż"],
  "excludeShiftWork": true,
  "strictLocation": true,
  "includeDetails": true,
  "maxItems": 100
}
```

#### Remote B2B IT jobs with a salary

```json
{
  "sources": ["justjoin", "nofluffjobs", "theprotocol", "pracuj", "rocketjobs"],
  "searchQueries": ["python"],
  "workArrangement": ["remote"],
  "contractTypes": ["b2b"],
  "seniority": ["senior"],
  "minSalary": 20000,
  "maxItems": 200
}
```

#### Salary research across a voivodeship

Read jobs with a salary from all general boards and open the free `SUMMARY` record: monthly salary quartiles (gross and B2B apart) by portal, town, category, contract type and level.

```json
{
  "searchQueries": ["księgowa"],
  "voivodeships": ["slaskie"],
  "onlyWithSalary": true,
  "maxItems": 1000
}
```

### How it works

#### Merging duplicates

The same job on several portals becomes one row with all its portals and links. Two ads are the same job when they are on **different portals** and have the same title (without the gender marker such as "(k/m)"), the same employer (without its legal form such as "sp. z o.o." or "S.A."), the same town and, where both portals give them, the same postal code and workplace coordinates (at most 5 km apart). Two ads of one portal are always two jobs (e.g. two shops of a chain in Warsaw). The most complete ad is kept and filled from the others. `portals` lists all portals of the job, `sources` every ad with its URL, `duplicates` how many ads were merged. Jobs without an employer name (sole traders, labour office offers that hide the employer, a portal's placeholder such as "Klient portalu Praca.pl") are never merged. Turn off **Merge duplicates across portals** for one row per ad.

#### Filters across portals

Each portal gets the search in its own terms (towns, voivodeships, distance rounded up to the nearest one the portal offers, work modes, contract types, levels, salary, date). Where a portal has no such filter:

- **Voivodeships** on JustJoin.it, RocketJobs.pl, NoFluffJobs and theprotocol.it: the portal reads the whole country and the actor keeps the jobs in your voivodeships.
- **Minimum salary** on Praca.gov.pl: the actor compares the monthly equivalent (the website itself would compare hourly rates with a monthly amount).
- **Work mode**, **contract types** or **position level** a portal does not know (InfoPraca has no work mode or contract filter; OLX, Praca.gov.pl and InfoPraca no level filter): the portal is **not read**, and the status message and `SUMMARY` say why.
- **Distance** on Praca.pl, NoFluffJobs and theprotocol.it: the towns are searched as the portals do.

The status message says how many jobs your filters left out, and `SUMMARY` (`counts.filteredOutBy`) says by which filter.

#### Monitoring mode

With **Monitoring: only new or changed jobs** the actor remembers the merged jobs of the previous run with the same **Monitoring key** and saves only jobs that are new (`changeType: new`), back after being removed (`reappeared`), or whose title, company, salary, town or portals changed (`updated`, with `changedFields`). With **Monitoring: include removed jobs** it also saves the jobs that are gone from **every** portal that had them (`changeType: removed`, `removedAt`, `lastSeenAt`), once. A removal is reported only for portals whose search was read to the end, so a job cut off by **Max jobs** is never reported as removed; set **Max jobs** high enough (or 0) for the whole search.

#### Notifications

Fill in one or more channels in the **Notifications** section (Telegram bot token and chat ID, Slack or Discord webhook, WhatsApp access token with your business phone number ID and the recipient's number, or any HTTPS webhook). After the run, the actor sends the title, company, place, salary and link of the saved jobs (at most **Notifications: max jobs per message**) and links to the run and the dataset; with **only when something was saved** (on by default) a run without new jobs sends nothing. Tokens and URLs are secret inputs, never logged. A run that sent its notification pays **$0.001** once (all channels together); a run that sends nothing, or whose channels all fail, pays nothing.

#### Market summary (SUMMARY)

Every run saves a free JSON record `SUMMARY` in the key-value store: jobs found, merged, left out by your filters (and by which) and saved; monthly salary quartiles in PLN overall, by kind (gross, net + VAT), by portal, voivodeship, town, category, contract type and level; top employers; work modes, contract types, levels and the share of shift work; and for every portal the jobs read, its status message, the filters it could not apply and how many saved jobs were found there.

#### Compact output, description format and exports

**Compact output** saves only the core fields (`id`, `portal`, `portals`, `url`, `title`, `company`, `location`, `region`, the salary fields, `contractTypes`, `workArrangement`, `seniority`, `postedAt`, `scrapedAt`), plus the description and the monitoring fields when those are on. **Description format** gives `description` as plain text, Markdown or simple HTML, made the same way for every portal. Extra export formats: a printable HTML report or a Markdown table, besides Excel, CSV and JSON.

### How much does it cost?

Pay per result. Every saved job pays:

1. the price of **its portal** (the table above, the same as the portal's own actor; a job found on several portals pays its **cheapest** portal **once**, so merging never makes a job dearer), and
2. with **Add description and details**, the job page price of its portal's own actor (the table above), charged as **Job page** units of $0.00001 (e.g. 39 units = $0.39 per 1 000 for Pracuj.pl). A merged job pays the page once, at its cheapest portal whose page was read, and
3. the **aggregation** (merging, one schema, filters and monitoring across portals): **$0.12 per 1 000 jobs** ($0.12 Bronze, $0.10 Silver, $0.08 Gold and higher plans).

| Example (FREE plan) | Price |
|---|---|
| 1 000 jobs from Pracuj.pl | $0.94 + $0.12 = **$1.06** |
| 1 000 jobs from Pracuj.pl, OLX, Praca.gov.pl and RocketJobs.pl (a quarter each) | about **$1.15** |
| 1 000 jobs from the labour offices with details | $1.19 + $0.20 + $0.12 = **$1.51** |
| 1 000 IT jobs from JustJoin.it, NoFluffJobs and theprotocol.it (a third each) | about **$0.78** |

**Start: $0.005 per run.** Notifications: **$0.001 per run** that sent one. **Monitoring:** an unchanged job is not saved, but it was read again, so it pays a small check fee per 1 000 jobs: $0.02 (Pracuj.pl $0.04), with details +$0.10 (Pracuj.pl +$0.45, Praca.gov.pl, InfoPraca and NoFluffJobs +$0.06, OLX +$0.02), always much less than saving it; a removed job pays like a saved one. **Extra pages:** pages a portal reads beyond its saved jobs (a narrow filter, a search without results) pay $0.15 per 1 000 pages (Pracuj.pl $1.00); a normal run pays nothing here. Merged duplicates, filtered-out jobs and the `SUMMARY` record are free. Only a run whose reading costs more than everything it charged (slow or rejecting portals, or many pages for very few saved jobs) pays a small top-up that covers its running cost; a normal run pays nothing here. You can set a maximum cost per run: the portals then read only as many jobs as it pays for, and saving stops when it is reached.

### Input example

```json
{
  "sources": ["pracuj", "olx-praca", "praca-gov-pl", "praca-pl", "rocketjobs", "aplikuj", "infopraca"],
  "searchQueries": ["magazynier"],
  "locations": ["Warszawa"],
  "maxItems": 200,
  "maxItemsPerSource": 50
}
```

### Output example

```json
{
  "id": "pl-jobs:3f1c9a2b7d4e5f60",
  "portal": "rocketjobs",
  "portals": ["rocketjobs", "pracuj"],
  "sources": [
    {"portal": "rocketjobs", "url": "https://rocketjobs.pl/oferta-pracy/level-work-magazynier-magazynierka-k-m-warszawa", "id": "rocketjobs:…", "detailScraped": false},
    {"portal": "pracuj", "url": "https://www.pracuj.pl/praca/magazynier-magazynierka-k-m-warszawa,oferta,…", "id": "pracuj:…", "detailScraped": false}
  ],
  "duplicates": 1,
  "url": "https://rocketjobs.pl/oferta-pracy/level-work-magazynier-magazynierka-k-m-warszawa",
  "title": "Magazynier / Magazynierka (K/M)",
  "company": "Level Work",
  "location": "Warszawa",
  "region": "mazowieckie",
  "salaryMin": 6000,
  "salaryMax": 6500,
  "salaryCurrency": "PLN",
  "salaryPeriod": "month",
  "salaryKind": "gross",
  "salaryMonthlyMin": 6000,
  "salaryMonthlyMax": 6500,
  "contractTypes": ["employment"],
  "workArrangement": "onsite",
  "seniority": ["junior"],
  "shiftWork": null,
  "postedAt": "2026-11-13T11:05:16Z",
  "country": "PL",
  "scrapedAt": "2026-11-17T12:00:00Z"
}
```

See the **Output** tab for all fields. The dataset has views **Overview**, **Portals and duplicates**, **Salaries** and **Monitoring**.

### Limitations

- Each portal reads at most **Max pages per search** pages per search term and town (by default about twice what it needs for its share of **Max jobs**); raise it for narrow filters.
- Each portal searches the keywords its own way, so the same search gives a different number of jobs on each portal. Praca.gov.pl searches the job title only.
- The portals word the same job differently, so not every duplicate is found; matching is strict, so two different jobs are never joined.
- **Towns:** Praca.pl adds relocation offers abroad to town searches; the actor leaves them out. Aplikuj.pl adds recommended offers from elsewhere to its results; the actor keeps only those within the distance (or the voivodeship) you searched. A town a portal does not know gives no jobs from that portal (the status message says "towns not found on …"), never the jobs of the whole country.
- With **Max jobs** the jobs are saved in the order of the portals you chose, so the last portals may be cut; set **Max jobs per portal** for an even mix.
- `shiftWork: null` means that nothing said whether the job is shift work, not that it is day work. The text of a job is fuller with **Add description and details** (OLX and Praca.gov.pl always have it).
- Salaries are in the currency the portal shows (mostly PLN; IT jobs sometimes EUR or USD); no exchange rate is applied. Gross salaries (umowa o pracę) and net + VAT (B2B) are not comparable; `salaryKind` says which one a row has.
- Near the run's timeout the actor stops reading, keeping time to save and charge what it has read. A portal that cannot be read (blocked, website change) is skipped and named in the status message, the others are saved.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/polish-jobs-aggregator").call(run_input={
    "searchQueries": ["kierowca"], "voivodeships": ["mazowieckie"], "maxItems": 200,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["salaryMonthlyMin"], job["portals"])
```

### More Polish job scrapers

The same output format for the other Polish job boards (monitoring mode, salaries as numbers):

- [Pracuj.pl Scraper](https://apify.com/tsutseisoftware/pracuj-scraper): the biggest Polish job board: salary, contract types, work modes, company, monitoring
- [NoFluffJobs Scraper](https://apify.com/tsutseisoftware/nofluffjobs-scraper): Polish IT jobs: salary per month and hour, B2B or employment, technologies, salary benchmark, monitoring
- [JustJoin.it Scraper](https://apify.com/tsutseisoftware/justjoin-it-scraper): Polish IT jobs: salary per contract type, technologies with level, seniority, remote, radius from a city, alerts
- [RocketJobs.pl Scraper](https://apify.com/tsutseisoftware/rocketjobs-pl-scraper): Polish non-IT jobs (sales, marketing, logistics and more): salary per contract type, subcategories, radius from a city, alerts
- [Praca.pl Scraper](https://apify.com/tsutseisoftware/praca-pl-scraper): jobs from one of the oldest Polish job boards: salary, contract type, work mode, relocation offers, monitoring
- [OLX Praca Scraper](https://apify.com/tsutseisoftware/olx-praca-scraper): Polish job ads from OLX: salary as written, place, company or private advertiser, optional job data and phone numbers of companies
- [theprotocol.it Scraper](https://apify.com/tsutseisoftware/theprotocol-it-scraper): Polish IT jobs: B2B and employment salary apart, seniority, technologies, hiring signals, monitoring
- [Praca.gov.pl Scraper](https://apify.com/tsutseisoftware/praca-gov-pl-scraper): all Polish labour office offers (CBOP): gross salary, employer and contact, voivodeship, contract, monitoring
- [Aplikuj.pl Scraper](https://apify.com/tsutseisoftware/aplikuj-pl-scraper): Polish jobs from Aplikuj.pl: salary per month and hour, direct employers only, contract, benefits, phone numbers of employers, monitoring
- [InfoPraca Scraper](https://apify.com/tsutseisoftware/infopraca-scraper): Polish jobs and jobs abroad from InfoPraca.pl: salary per month and hour, voivodeship, category, phone numbers of companies, monitoring

Need jobs straight from company career sites in any country? [Career Site Job Search](https://apify.com/tsutseisoftware/ats-jobs-scraper) searches Greenhouse, Workday, Lever, Ashby and SmartRecruiters job boards without a company list, including the jobs that just closed.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

#### Is it legal to scrape Polish job boards?

The actor reads only job ads that the portals publish for everyone without logging in, at a polite speed; it slows down when a website asks and never solves captchas or other challenges. It returns no recruiter contacts of the commercial portals and removes e-mails and phone numbers from descriptions; the names of private employers (sole traders) are hidden. Praca.gov.pl publishes the contact of each offer (person, phone, e-mail), which the actor returns in `contactName`, `contactPhone` and `contactEmail`; for sole traders and contact persons that is personal data. You are responsible for how you use the data (GDPR, database rights and the websites' terms). This actor is not affiliated with any of the portals.

#### Why is a job not merged with its copy on another portal?

The portals often word the same job differently (another title, the employer's brand instead of its legal name, a district instead of the town). Matching is strict, so that two different jobs are never joined.

#### Why was a portal not read?

Because it cannot apply one of your filters (work mode, contract type or position level) and would return jobs that do not match. The status message and `portalReport` in `SUMMARY` name the portal and the reason. Remove the filter, or pick the portals that have it.

#### Can I get one portal only?

Yes, choose one portal; you pay its price plus the aggregation. For one portal its own actor is cheaper, e.g. [Pracuj.pl Scraper](https://apify.com/tsutseisoftware/pracuj-scraper) or [Praca.gov.pl Scraper](https://apify.com/tsutseisoftware/praca-gov-pl-scraper).

***

Also known as a Polish jobs API, Poland job aggregator or Polish job board scraper (Polish: "oferty pracy z wielu portali", "agregator ofert pracy", "wszystkie oferty pracy w jednym miejscu", "oferty pracy do Excela").

# Actor input Schema

## `sources` (type: `array`):

Portals to read. By default the 7 general job boards; pick JustJoin.it, NoFluffJobs and theprotocol.it for IT jobs. A job found on several portals is one row and pays the price of its cheapest portal once. Pracuj.pl uses a Polish residential proxy (included in the price).

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

Job titles or keywords in Polish, e.g. "magazynier", "kierowca", "księgowa", "python". Each term is a separate search on every portal. Empty = the newest jobs.

## `locations` (type: `array`):

Polish towns, e.g. "Warszawa", "Kraków", "Wrocław" (diacritics optional). Each town is a separate search on every portal.

## `voivodeships` (type: `array`):

Whole voivodeships. With towns as well, the portals read both (Pracuj.pl and the IT boards then read the towns only).

## `radiusKm` (type: `integer`):

With "Towns": also jobs up to this distance, on the portals that search by distance (Pracuj.pl, OLX, Praca.gov.pl, Aplikuj.pl, InfoPraca, JustJoin.it, RocketJobs.pl; the nearest distance a portal offers is used). Empty = each portal's default.

## `maxItems` (type: `integer`):

Maximum number of jobs saved (after merging duplicates). 0 = no limit.

## `maxItemsPerSource` (type: `integer`):

How many jobs each portal reads at most. 0 = its share of "Max jobs" (Max jobs ÷ number of portals + 20 %).

## `maxPagesPerSearch` (type: `integer`):

How many result pages each portal reads per search term and town. Empty or 0 = about twice what the portal needs for its share of "Max jobs" (at most 50). Raise it for narrow filters: pages a portal reads beyond its saved jobs pay a small fee of $0.15 per 1 000 (Pracuj.pl $1.00).

## `workArrangement` (type: `array`):

Only jobs with one of these work modes. InfoPraca has no such filter and is not read with it.

## `minSalary` (type: `integer`):

Only jobs whose monthly salary reaches at least this amount in PLN (the top of the range; hourly rates are converted at standard full-time hours). Jobs without a salary are left out.

## `onlyWithSalary` (type: `boolean`):

Only jobs that show a salary (widełki).

## `contractTypes` (type: `array`):

Only jobs offering one of these contracts (UoP, B2B, zlecenie…). A portal without any of them, or without a contract filter (InfoPraca), is not read.

## `seniority` (type: `array`):

Only jobs for these levels. OLX, Praca.gov.pl and InfoPraca have no level filter and are not read with it.

## `postedWithinDays` (type: `integer`):

Only jobs published or refreshed in the last N days. Empty = any age.

## `excludeKeywords` (type: `array`):

Leave out jobs with one of these words in the title.

## `companies` (type: `array`):

Only jobs of companies whose name contains one of these.

## `excludeCompanies` (type: `array`):

Leave out jobs of companies whose name contains one of these (e.g. agencies).

## `includeTerms` (type: `array`):

Keep a job only if its title, company, category, technologies or description mention one of these (diacritics optional), e.g. "laborant", "chemi". The relevance filter a portal's own search cannot do. The description is there with "Add description and details" (OLX and Praca.gov.pl always).

## `includeTermsMode` (type: `string`):

"At least one term" for a list of synonyms, "All terms" when every one must be there.

## `excludeTerms` (type: `array`):

Leave out a job whose title, company, category or description mentions one of these, e.g. "staż", "praktyki", "agencja pracy".

## `excludeShiftWork` (type: `boolean`):

Leave out jobs marked as shift or night work by the portal or saying so in their text ("praca zmianowa", "dwie zmiany", "zmiana nocna"; "jedna zmiana" is kept). shiftWork in the output says what was found; null means nothing was said, not day work.

## `strictLocation` (type: `boolean`):

Keep only jobs in the towns you gave, not the nearby places the portals add (e.g. Pruszków for Warszawa).

## `includeDetails` (type: `boolean`):

Open each job page for the description, requirements, benefits and other details (slower). A job page pays what the portal's own scraper charges for it: Pracuj.pl $0.39, Praca.gov.pl (labour offices) $0.20, Praca.pl $0.35, RocketJobs.pl $0.15, Aplikuj.pl $1.25, InfoPraca.pl $0.25, JustJoin.it $0.15, NoFluffJobs $0.05, theprotocol.it $0.10 per 1 000 jobs; OLX ads always have their text. A job on several portals pays its page once, at the cheapest portal whose page was read.

## `mergeDuplicates` (type: `boolean`):

One row per job when the same job is on several portals, with all its portals and links in "portals" and "sources". Off = one row per ad.

## `descriptionFormat` (type: `string`):

Format of "description", the same for every portal: plain text, Markdown (headings and lists, good for AI agents and Notion) or simple HTML (<h3>, <ul>, <p>).

## `compactOutput` (type: `boolean`):

Only the core fields (id, portals, URL, title, company, town, voivodeship, salary, contract types, work mode, level, dates), plus the description and the monitoring fields when those are on. Smaller rows for AI agents, MCP clients and spreadsheets.

## `onlyNewOrChanged` (type: `boolean`):

Return only jobs that are new or whose title, company, salary, town or portals changed since the previous run with the same Monitoring key. Unchanged jobs are not saved and pay only a small check fee ($0.02 per 1 000, see the README).

## `includeRemovedJobs` (type: `boolean`):

Also save the jobs of the previous run that are gone from every portal that had them (changeType "removed"), each once. Reported only for portals whose search was read to the end, so set "Max jobs" high enough (or 0) for the whole search. A removed job pays like a saved one.

## `monitoringKey` (type: `string`):

Name of the remembered state; use a different key for each search you monitor.

## `telegramBotToken` (type: `string`):

Token of your Telegram bot (from @BotFather). Used with "Telegram chat ID".

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `webhookUrl` (type: `string`):

Any HTTPS URL: gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many jobs are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no job (e.g. a monitoring run without new jobs).

## `exportFormats` (type: `array`):

Off by default. Printable HTML report: the results as a clean, branded table with the main columns, made for printing, saving as PDF or sending to someone; for working with the data use Excel or CSV, which have every field. Markdown table: the same columns as text for AI tools, docs or GitHub. The Output tab links the files. Each file has the overview columns of every saved row and nothing is left out, so a run with tens of thousands of rows makes a file of tens of MB that can be slow to open; for big runs use the dataset or its Excel export. Excel (XLSX), CSV and JSON are always in the Output tab and under Export, at no extra cost.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "sources": [
    "pracuj",
    "olx-praca",
    "praca-gov-pl",
    "praca-pl",
    "rocketjobs",
    "aplikuj",
    "infopraca"
  ],
  "searchQueries": [
    "magazynier"
  ],
  "locations": [
    "Warszawa"
  ],
  "maxItems": 30,
  "maxItemsPerSource": 5,
  "onlyWithSalary": false,
  "includeTermsMode": "any",
  "excludeShiftWork": false,
  "strictLocation": false,
  "includeDetails": false,
  "mergeDuplicates": true,
  "descriptionFormat": "text",
  "compactOutput": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "exportFormats": [],
  "sendErrorReports": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

The saved jobs, duplicates across portals merged, in the run's default dataset.

## `summary` (type: `string`):

Free summary: monthly salary quartiles in PLN by portal, voivodeship, town, category, contract type and level, top employers, and per portal the jobs read and saved.

## `excel` (type: `string`):

All saved rows as an Excel file, with every field.

## `htmlReport` (type: `string`):

The saved rows with the main columns as a clean table to print, save as PDF or send; only when "Extra export formats" includes it. Excel has every field.

## `markdown` (type: `string`):

The saved rows as a Markdown table, handy for AI tools, docs and GitHub; only when "Extra export formats" includes Markdown.

# 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 = {
    "sources": [
        "pracuj",
        "olx-praca",
        "praca-gov-pl",
        "praca-pl",
        "rocketjobs",
        "aplikuj",
        "infopraca"
    ],
    "searchQueries": [
        "magazynier"
    ],
    "locations": [
        "Warszawa"
    ],
    "maxItems": 30,
    "maxItemsPerSource": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/polish-jobs-aggregator").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 = {
    "sources": [
        "pracuj",
        "olx-praca",
        "praca-gov-pl",
        "praca-pl",
        "rocketjobs",
        "aplikuj",
        "infopraca",
    ],
    "searchQueries": ["magazynier"],
    "locations": ["Warszawa"],
    "maxItems": 30,
    "maxItemsPerSource": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/polish-jobs-aggregator").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 '{
  "sources": [
    "pracuj",
    "olx-praca",
    "praca-gov-pl",
    "praca-pl",
    "rocketjobs",
    "aplikuj",
    "infopraca"
  ],
  "searchQueries": [
    "magazynier"
  ],
  "locations": [
    "Warszawa"
  ],
  "maxItems": 30,
  "maxItemsPerSource": 5
}' |
apify call tsutseisoftware/polish-jobs-aggregator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tsutseisoftware/polish-jobs-aggregator"
        }
    }
}
```

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/gxnR2E0OGlWW4K87N/builds/qA2OrlgthD7vdJtcd/openapi.json
