# Praca.gov.pl Scraper ($1.19/1K): Polish Labour Office Jobs (`tsutseisoftware/praca-gov-pl-scraper`) Actor

Scrape praca.gov.pl (CBOP), the job offers of all Polish labour offices: salary per month and hour, employer, town, voivodeship, contract, duties and requirements. Website filters, optional details, monitoring of new and removed offers, notifications. Unofficial. Oferty pracy urzędów pracy.

- **URL**: https://apify.com/tsutseisoftware/praca-gov-pl-scraper.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 $1.05 / 1,000 jobs

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

## Praca.gov.pl Scraper: Polish Labour Office Jobs (CBOP)

Get the job offers of **all Polish labour offices** from **praca.gov.pl** (Centralna Baza Ofert Pracy, CBOP: about 16 500 offers with 46 000 vacancies) as a clean table. Search by **job title keywords**, **towns with a distance**, **voivodeships** and the website's own filters, or paste offer URLs. For each offer you get the title, **employer and the contact person, phone and e-mail the offer names**, town with its **voivodeship** and coordinates, **gross salary in PLN with monthly and hourly equivalents**, contract, working time, **duties and requirements**, dates (added, valid until, start), the labour office that handles it and its labels (for people with disabilities, for registered jobseekers only, abroad). Optionally the actor adds the **details of each offer**: number of vacancies, occupation code, employer tax ID (NIP) and website, full workplace address with postal code and county, hours per week, shifts, accommodation and meals, and the required education, languages and licences as lists.

The **whole database** fits in one run of a few minutes. Filtered-out offers are not saved and not charged.

> **Po polsku:** Scraper i API ofert pracy z urzędów pracy: pobiera oferty wszystkich powiatowych urzędów pracy (PUP), wojewódzkich urzędów pracy i OHP z **praca.gov.pl** (Centralna Baza Ofert Pracy, CBOP): wynagrodzenie brutto w PLN miesięcznie i godzinowo, pracodawcę, osobę kontaktową z telefonem i e-mailem, miejscowość, województwo, rodzaj umowy, wymiar etatu, zakres obowiązków, wymagania i urząd pracy. Filtry stanowiska, miejscowości z promieniem, województwa, rodzaju umowy, trybu pracy, wynagrodzenia i daty, szczegóły oferty (NIP, liczba miejsc, kod zawodu, adres), monitoring nowych i usuniętych ofert, powiadomienia w Telegramie, Slacku, Discordzie i WhatsAppie oraz podsumowanie rynku. Bez proxy. Eksport do Excela, CSV lub JSON.

### Why use this praca.gov.pl scraper?

- 🏛️ **The labour offices' own database.** CBOP collects the offers of all 340 county labour offices (PUP), the voivodeship offices and the youth labour corps (OHP): manual, public-sector and regional jobs that the commercial job boards often don't have.
- 💰 **Every offer has a salary.** The website asks employers for the gross salary, so 100 % of offers have one: `salaryMin`/`salaryMax` as numbers, the currency, `salaryPeriod` (month or hour) and **monthly and hourly equivalents** for comparing them; the employer's note on bonuses stays in `salaryNote`.
- 🔎 **The website's own filters:** job title keywords, **towns with a distance** (5–75 km), voivodeships, offer type (job, internship, apprenticeship, volunteering), contract type, work mode (on site, hybrid, remote), working time, salary from / up to, posted in the last N days, Poland or abroad (EURES), immediate start, temporary work, for people with disabilities, accommodation, meals. Plus the actor's own: title must not contain, exclude companies, leave out offers for registered jobseekers only, without the employer's name or for the whole of Poland (the website adds these to every town and voivodeship search).
- 📋 **Details when you need them** ("Add details"): number of vacancies, occupation with its code (Polish classification based on ISCO-08), employer tax ID (NIP), sector and website, full workplace address with postal code, county and municipality, hours per week, working hours, shifts, work mode, salary system, bonuses and benefits, immediate start, accommodation and meals, and the **required education, languages, licences and occupations as lists**.
- ✅ **Complete results.** Now and then the website cannot show one offer, and that breaks a whole page of its list; the actor reads such a page again in smaller parts, so only that one offer is missing, and the status says how many. A whole search is checked against the website's own count.
- 📬 **Monitoring mode:** a daily feed of new and changed offers (`changeType`), optionally with **removed offers** (`expired` or `ended`).
- 🔔 **Notifications** to **Telegram, Slack, Discord, WhatsApp** or **your webhook** after each run.
- 📊 **Free market summary** (SUMMARY): salary median and quartiles by voivodeship, town, contract and employment type, top employers and labour offices, contract kinds and offer types.
- 🛡️ **No proxy needed**, no extra platform cost: you pay only the prices below.
- 👤 **Employers and contacts as the labour office publishes them.** Every row has the employer's name (also sole traders named after their owner) and the contact person, phone number and e-mail the offer gives (91 % of offers name one), at no extra cost. Only the employers the labour office itself keeps to itself (about 7 %, "kontakt przez PUP": apply through the office) have no name (`companyHidden`). See "Personal data" below.

### What data can you get?

| Field | Example |
|---|---|
| Title, employer, employer's town | Kierowca autobusu (Klaudyn) K/M, RELOBUS TRANSPORT POLSKA SP. Z O.O., Warszawa |
| Contact | contactName, contactPhone `+48605457457`, contactEmail |
| Place of work | Klaudyn, mazowieckie, Polska; latitude 52.279, longitude 20.876; TERYT town code |
| Abroad, whole Poland | isAbroad, country `Niemcy`; wholePoland |
| Salary | 7 200 – 10 500 PLN per month, gross (hourly 45.00 – 65.62), the employer's note |
| Contract and working time | contractType "Umowa o pracę na czas nieokreślony", contractKind `employment`; workingTime "1", fullTimeShare 1.0, employmentType `fullTime` |
| Texts | responsibilities, requirements (as published) |
| Dates | postedAt, validFrom, validUntil, startDate |
| Labour office | laborOffice, addedBy `PUP`, applyVia `employer` / `laborOffice`, onlyRegisteredJobseekers, forDisabled, labels |
| With details | offerNumber, vacancies, occupation, occupationCode, companyTaxId, companySector, companyWebsite, workAddress, postalCode, county, municipality, hoursPerWeek, shifts, workModes, salarySystem, immediateStart, accommodation, meals, educationRequired, languagesRequired, licensesRequired, occupationsRequired, laborOfficeAddress |
| Monitoring | changeType, changedFields, previousValues, firstSeenAt, removedAt, removedReason |

**How complete the data is** (the whole database, 16 400 offers, November 2026): salary 100 % (PLN 99 %, a few offers abroad in EUR, NOK or CZK; per hour 15 %), coordinates 97 %, voivodeship or country 99.9 %, contract type 99.8 %, offers abroad about 1 %, offers for the whole of Poland about 1 %. A contact person, phone or e-mail is named by 91 % of the offers; the employer's name is shown for 93 % (the rest the labour office keeps to itself).

### How to scrape praca.gov.pl

1. Enter **Search keywords** (e.g. `kierowca`, `magazynier`), **Towns** (`Kraków`, with **Distance from the town** if you like) or **Voivodeships**, or leave them empty for all offers.
2. Set **Max jobs** (0 = everything that matches) and the filters you need.
3. Turn on **Add details** if you need the vacancies, occupation code, tax ID or the full address.
4. Run it and download the results as Excel, CSV, JSON or via the API. Schedule it with **Monitoring** on for a daily feed.

### Use cases

#### New driver jobs within 30 km of Kraków every morning

```json
{
  "searchTerms": ["kierowca"],
  "locations": ["Kraków"],
  "radiusKm": 30,
  "maxItems": 0,
  "onlyNewOrChanged": true,
  "monitoringKey": "kierowca-krakow"
}
```

#### Warehouse jobs on an employment contract in Masovia, at least 5 000 PLN

```json
{
  "searchTerms": ["magazynier"],
  "voivodeships": ["14"],
  "contractTypes": ["employment"],
  "minSalary": 5000,
  "maxItems": 200
}
```

#### Every offer added in the last day, with details (vacancies, occupation code, tax ID)

```json
{
  "postedWithinDays": 1,
  "includeDetails": true,
  "maxItems": 0
}
```

#### The whole database for a labour-market analysis

```json
{
  "maxItems": 0
}
```

#### Offers abroad (EURES) with accommodation

```json
{
  "country": "abroad",
  "accommodation": true,
  "maxItems": 0
}
```

#### Selected offers by URL

```json
{
  "startUrls": [
    { "url": "https://oferty.praca.gov.pl/portal/lista-ofert/szczegoly-oferty/d674567df1e099622735628f0d5daa2b" }
  ]
}
```

An offer URL (or the bare offer ID) is read from the offer's page and saved as one job; its details are kept and charged only when **Add details** is on. An ended offer is reported as not found.

#### Personal data (contacts and sole traders)

The rows contain what the labour offices publish on praca.gov.pl for everyone: the employer's name, also when it is a sole trader named after the owner, and the contact person, phone number and e-mail of the offer (often the employer's recruiter, sometimes the labour office's officer). Contact names and the names of sole traders are personal data. The offices publish them so that jobseekers can apply; if you process them further, you are responsible for doing so lawfully under the GDPR (a legal basis, informing the people, no unsolicited marketing where the law forbids it). A person who asks us not to be returned is left out.

#### Monitoring mode explained

With **Monitoring: only new or changed jobs** the actor remembers what it saw (under your **Monitoring key**) and returns only offers that are new or whose title, employer, salary, place, contract, working time, end date, duties or requirements changed. Unchanged offers are free; every page of results read is charged as a monitoring page. With **Monitoring: include removed jobs** you also get the offers that left the search since the last run: `expired` when the end date passed, `ended` when the website no longer shows the offer (checked on its page).

#### Notifications (Telegram, Slack, Discord, WhatsApp, webhook)

Fill in a Telegram bot token and chat ID, a Slack or Discord webhook, a WhatsApp access token with your business phone number ID and the recipient's number, or your own HTTPS URL. After each run (by default only when something was saved) you get the title, employer, place, salary and link of the saved offers. Nothing else is sent.

#### Market summary (SUMMARY)

Every run saves a free summary in the key-value store (record `SUMMARY`): the website's count of the search and its number of vacancies, salary quartiles (monthly gross PLN) overall and by voivodeship, town, contract kind and employment type, top employers and labour offices, contract kinds, offer types and voivodeships.

Extra export formats: a printable HTML report or a Markdown table, besides Excel, CSV and JSON (**Extra export formats**, off by default).

### How much does it cost to scrape praca.gov.pl?

Pay per result, no subscription, **no proxy or platform costs on top**. Employers and contacts are included in the price of the job.

| What | FREE | BRONZE | SILVER | GOLD+ |
|---|---|---|---|---|
| 1 000 jobs | **$1.19** | $1.15 | $1.09 | $1.05 |
| Details ("Add details", per 1 000 jobs) | +$0.20 | +$0.20 | +$0.20 | +$0.20 |
| **1 000 jobs with details** | **$1.39** | $1.35 | $1.29 | $1.25 |
| Run start | $0.003 | $0.003 | $0.003 | $0.003 |

Other events, only when they happen: **monitoring page** $0.30 per 1 000 pages of results read in monitoring mode, **extra page** $0.30 per 1 000 pages read beyond what the saved jobs cover (a filter that keeps few offers, a search without results, towns looked up, pages read again in parts), **notification** $0.001 per run that sent one. If the saved jobs don't cover a run's cost (e.g. the website answers very slowly), the difference is charged as extra pages; the log says how many. A normal run pays nothing more.

| Typical run | Price (FREE) | Typical time |
|---|---|---|
| 20 jobs (the example input) | $0.03 | a few seconds |
| 1 000 jobs | $1.19 | about 15 s |
| 1 000 jobs with details | $1.39 | about 17 min |
| The whole database (~16 500 offers) | about $19.70 | about 5 min |
| Daily monitoring of a town search, ~5 new offers a day | about $0.01 a day | a few seconds |

### Input example

```json
{
  "searchTerms": ["kierowca"],
  "maxItems": 20
}
```

### Output example

```json
{
  "id": "d674567df1e099622735628f0d5daa2b",
  "source": "praca.gov.pl",
  "url": "https://oferty.praca.gov.pl/portal/lista-ofert/szczegoly-oferty/d674567df1e099622735628f0d5daa2b",
  "title": "Kierowca autobusu (Klaudyn) K/M",
  "company": "RELOBUS TRANSPORT POLSKA SPÓŁKA Z OGRANICZONĄ ODPOWIEDZIALNOŚCIĄ",
  "companyHidden": null,
  "companyAddress": "Warszawa, mazowieckie",
  "location": "Klaudyn, mazowieckie",
  "city": "Klaudyn",
  "region": "mazowieckie",
  "country": "Polska",
  "latitude": 52.2792368,
  "longitude": 20.8757287,
  "salaryMin": 7200,
  "salaryMax": 10500,
  "salaryCurrency": "PLN",
  "salaryPeriod": "month",
  "salaryType": "gross",
  "salaryMonthlyMin": 7200,
  "salaryMonthlyMax": 10500,
  "salaryHourlyMin": 45.0,
  "salaryHourlyMax": 65.62,
  "salaryNote": "Wynagrodzenie 7 200 do 10 500 zł brutto. Pracodawca oferuje: - dodatek za godziny nocne, …",
  "offerType": "job",
  "contractType": "Umowa o pracę na czas nieokreślony",
  "contractKind": "employment",
  "fullTimeShare": 1.0,
  "employmentType": "fullTime",
  "permanentWork": true,
  "responsibilities": "Transport pasażerów na terenie Warszawy.",
  "requirements": "wykształcenie - podstawowe\nzawód - Kierowca autobusu\n…\nKontakt: e-mail: rekrutacja@relobus.pl, tel. 605 457 457.",
  "postedAt": "2026-11-17",
  "validUntil": "2026-12-17",
  "startDate": "2026-11-17",
  "applyVia": "employer",
  "laborOffice": "Urząd Pracy Miasta Stołecznego Warszawy",
  "addedBy": "PUP",
  "contactName": null,
  "contactPhone": "+48605457457",
  "contactEmail": "rekrutacja@relobus.pl",
  "detailsIncluded": true,
  "offerNumber": "StPr/26/09960",
  "vacancies": 15,
  "occupation": "kierowca autobusu",
  "occupationCode": "833101",
  "companyTaxId": "5272185559",
  "postalCode": "05-080",
  "county": "warszawski zachodni",
  "hoursPerWeek": 40,
  "shifts": "trzy zmiany",
  "immediateStart": true,
  "licensesRequired": ["Przewóz osób", "kat. D prawo jazdy"],
  "scrapedAt": "2026-11-17T08:00:00Z"
}
```

(Shortened; every row has all fields, empty ones as `null` or `[]`.)

### Limitations

- The keyword search looks at the **job title** (as on the website), not at the duties or requirements.
- The website's salary filter compares the amounts as written, so an hourly rate is compared as it is (31 PLN per hour is below "from 5 000").
- The labour office hides the employer of about 7 % of the offers ("kontakt przez PUP": apply through the office); the actor returns what the website shows.
- A few offers a day cannot be shown by the website itself; they are skipped and counted in the status message.
- Offers are added and removed during the day, so the count of a big search can differ by a few offers from what a run reads.

### For AI agents and API users

Every row has a stable `id` (the website's offer ID), so repeated runs can be merged. Call it from the API, from MCP clients or schedule it; the dataset and the `SUMMARY` record are in the run's default storages.

### Troubleshooting

- **"Town not found on praca.gov.pl"**: write the town as on the website (`Bielsko-Biała`, `Zielona Góra`); for a name that several places share add the voivodeship after a comma (`Dąbrowa, opolskie`), or use **Voivodeships**.
- **"N offers the website itself could not show"**: the website has an error with these offers; they are skipped, everything else is saved.
- **"N pages could not be read, so the results may be incomplete"**: the website did not answer some pages; run it again later.
- **"praca.gov.pl is rejecting requests"**: a page the website rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. Try later or turn on Apify Proxy (automatic).

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

### More Polish job scrapers

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

- [Polish Jobs Aggregator](https://apify.com/tsutseisoftware/polish-jobs-aggregator): all these Polish job boards in one run: duplicates merged, one output format, salaries as numbers, monitoring
- [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
- [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.

### FAQ

#### Is it legal to scrape praca.gov.pl?

It reads only offers the labour offices publish for everyone, without logging in, at most 60 requests per minute, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. The rows include the contact persons, phone numbers and e-mails and the names of sole traders as the offices publish them; these are personal data, and you are responsible for processing them lawfully (GDPR), as well as for database rights and the website's terms. If in doubt, consult a lawyer. This actor is not affiliated with praca.gov.pl, the Polish labour offices or the Ministry.

#### Why is the employer empty for some offers?

The labour office does not show the employer of these offers (`companyHidden` = `laborOffice`, about 7 %): you apply through the office, whose name is in `laborOffice`.

#### How are salaries converted?

`salaryMin` and `salaryMax` are the gross amounts the website shows ("od 5 060 do 6 000 PLN"). Hourly and monthly equivalents use 160 hours per month. With **Add details** the offer's salary system can also mark a yearly salary.

#### Do I need a proxy?

No. The default is no proxy and the price includes everything. If you turn on a residential proxy yourself, every request through it is charged as 3 extra pages, because that traffic is paid by the megabyte.

This scraper is also known as a praca.gov.pl API, CBOP scraper or Centralna Baza Ofert Pracy export (Polish: "oferty pracy urzędów pracy", "urząd pracy oferty pracy", "oferty pracy PUP", "Centralna Baza Ofert Pracy").

# Actor input Schema

## `searchTerms` (type: `array`):

Words of the job title, in Polish, e.g. "kierowca", "magazynier", "księgowa", "opiekunka". The website searches the position of the offers; several lines = offers that match any of them. Empty = all offers that match the rest.

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

Towns by name, e.g. Warszawa, Kraków, Zielona Góra (for a name that several places share, add the voivodeship or county after a comma: "Dąbrowa, opolskie"). A voivodeship name works too. Offers for the whole of Poland are included, as on the website. A town the website does not know is reported in the status message.

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

Also offers within this many kilometres of each town. The website knows 5, 10, 20, 30, 50, 75 km; another value is rounded up to the next one. 0 = the town only.

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

Only offers in these voivodeships.

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

URLs of offers on oferty.praca.gov.pl (https://oferty.praca.gov.pl/portal/lista-ofert/szczegoly-oferty/…) or their IDs, e.g. to refresh offers you already have. Each is read from its page. For a search use the inputs above.

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

Maximum number of offers saved. You pay per saved offer. 0 = no limit (the database has about 16 500 offers).

## `sortBy` (type: `string`):

Order of the website's search. With a limit you get the first offers in this order.

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

Adds the offer number, number of vacancies, occupation and its code, employer tax ID (NIP), sector, type and website, full address of the workplace with postal code, county and municipality, hours per week, working hours, shifts, work mode, salary system, bonuses and benefits, immediate start, temporary work, accommodation and meals, the required education, languages, licences and occupations (as lists), nice-to-have skills, required documents and the labour office's address and phone.

## `offerTypes` (type: `array`):

Only offers of these kinds (most are job offers; the others are internships, apprenticeships and volunteering).

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

Only offers with one of these contracts.

## `workModes` (type: `array`):

Only offers with one of these work modes (on site, hybrid, remote).

## `workingTime` (type: `string`):

Only offers with at most this share of full-time work (the website's "wymiar etatu").

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

Only offers whose gross salary reaches this amount (the website compares the amounts as written, so hourly rates are compared as they are).

## `maxSalary` (type: `integer`):

Only offers whose gross salary starts at this amount or less.

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

Only offers added to the database in the last N days.

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

The website's choice between Polish offers and offers abroad (EURES).

## `immediateStart` (type: `boolean`):

Only offers marked "zatrudnienie od zaraz".

## `temporaryWork` (type: `boolean`):

Only offers of temporary work (praca tymczasowa).

## `forDisabled` (type: `boolean`):

Only offers open to people with disabilities.

## `accommodation` (type: `boolean`):

Only offers where the employer provides accommodation.

## `meals` (type: `boolean`):

Only offers where the employer provides meals.

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

Skip offers whose title has any of these words (without diacritics and case).

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

Skip offers of employers whose name has any of these words.

## `excludeRegisteredOnly` (type: `boolean`):

Skip offers that the labour office gives only to people registered with it (onlyRegisteredJobseekers).

## `excludeWholePoland` (type: `boolean`):

The website adds offers for the whole of Poland ("Cała Polska", about 1 % of all offers) to every town and voivodeship search, where they can be a fifth of the results. Turn on to keep only offers in the places you chose.

## `excludeHiddenEmployer` (type: `boolean`):

Skip offers where the labour office keeps the employer to itself ("kontakt przez PUP", about 7 %).

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

Save only offers that are new or changed since the previous run with the same Monitoring key (changed = title, employer, salary, place, contract, working time, end date, duties or requirements). Unchanged offers are free; each search request read is charged as "Monitoring page" instead (see Pricing). The first run returns everything.

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

Name of the saved state. Use a different key for each watched search (e.g. "kierowca-mazowieckie"). Empty = "default". The value is stored encrypted.

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

Also return offers that were in the previous run and are gone, as rows with changeType "removed" and removedReason "expired" (its end date passed) or "ended" (the website no longer shows it, e.g. the job was filled); an offer that comes back is "reappeared". An expired offer needs no request; the others are checked on their page (at most 300 per run, the rest in the next run), and an offer the website still shows is not reported. Checked only when the run reads the whole search (limits, "Posted in the last N days", offer URLs, unread pages or rejected requests skip the check, and the status message says why). Removed rows are charged like any other job.

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

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

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

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

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

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

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

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

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

Any HTTPS URL (Zapier, Make, n8n, your server): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}. Use it for e-mail or Teams through such a service.

## `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 offers are listed in one notification (the rest as "…and N more").

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

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

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

No proxy by default: the website answers Apify's IP addresses. If it starts rejecting requests, try Apify Proxy (automatic). A RESIDENTIAL proxy is not needed; if you choose it, every request through it is charged as 3 extra pages (see Pricing), because that traffic is paid by the megabyte.

## `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
{
  "searchTerms": [
    "kierowca"
  ],
  "radiusKm": 0,
  "maxItems": 20,
  "sortBy": "newest",
  "includeDetails": false,
  "country": "any",
  "immediateStart": false,
  "temporaryWork": false,
  "forDisabled": false,
  "accommodation": false,
  "meals": false,
  "excludeRegisteredOnly": false,
  "excludeWholePoland": false,
  "excludeHiddenEmployer": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "exportFormats": [],
  "sendErrorReports": true
}
```

# Actor output Schema

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

The saved offers (one row per offer), in the run's default dataset.

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

Free summary of the offers the run found: monthly gross salary quartiles in PLN (by voivodeship, town, contract, employment type), top employers and labour offices, contract kinds, offer types, the website's count of the search.

## `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 = {
    "searchTerms": [
        "kierowca"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/praca-gov-pl-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 = {
    "searchTerms": ["kierowca"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/praca-gov-pl-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 '{
  "searchTerms": [
    "kierowca"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/praca-gov-pl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tsutseisoftware/praca-gov-pl-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/gkbgwzXSNdwMcNkoB/builds/yh0KdgAwZznCQNwAn/openapi.json
