# OLX Praca Scraper ($0.99/1K): Polish Job Ads & Salaries (`tsutseisoftware/olx-praca-scraper`) Actor

Scrape job ads from OLX Praca (olx.pl): salary per month and hour, contract, working time, company, town, voivodeship, category and description. Website filters, automatic split of searches over 1,000 ads, monitoring of new and removed ads, notifications, market summary. Unofficial. Oferty pracy.

- **URL**: https://apify.com/tsutseisoftware/olx-praca-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 $0.51 / 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

## OLX Praca Scraper: Polish Job Ads & Salaries (olx.pl)

Get job ads from **OLX Praca** (olx.pl/praca), the biggest Polish source of jobs for manual workers, drivers, shop and warehouse staff, temporary and seasonal work (about **75 000 ads**), as clean structured data, about 1 500 ads a minute.

**A simple base price, add-ons only when you need them.**

- **Base row ($0.99 per 1 000 on the free plan):** everything the website gives for an ad, the same scope as a general OLX scraper: title, full description, salary as written (from, to, currency, period, gross or net), the raw parameters, town, district, voivodeship and map point, dates, category ID, business or private advertiser, company name and logo of business accounts, promotion flags and the link. Search by keyword, category, voivodeship, town with a radius, advertiser type or any search URL of the jobs section, with all the website's filters.
- **Add-ons, each off by default and charged only when used:** **Job data** (the ad parsed into salary per month and hour, contract types, working time, workplace, requirements, category names, application page), **Deep search** (more than 1 000 ads of one search), **Monitoring** (new, changed and removed ads), **Contacts**, **Phone numbers** of business ads, **Notifications**, **Fast mode**. See [pricing](#how-much-does-it-cost-to-scrape-olx-praca).

**Privacy is not an add-on.** About a quarter of the ads come from private persons. Their names are never returned, and e-mails and phone numbers are removed from titles and descriptions in every run.

Every run also saves a free **market summary** (salary quartiles in PLN by voivodeship and town; by category, working time and contract type with **Job data**). The output uses the same field names as our **Pracuj.pl**, **NoFluffJobs**, **JustJoin.it**, **Jobs.cz** and **Profesia** scrapers, so the data can go into one table.

> **Po polsku:** Scraper i API ogłoszeń o pracę z **OLX Praca** (olx.pl/praca): praca fizyczna, dla kierowców, w sklepach i magazynach, praca tymczasowa i sezonowa. Pobiera tytuł, pełny opis, wynagrodzenie (od, do, miesięcznie lub za godzinę, brutto lub netto), miejscowość, dzielnicę, województwo, daty i firmę. Filtry serwisu (kategoria, województwo, miasto z odległością, wymiar pracy, rodzaj umowy, praca zdalna, doświadczenie, dla osób z Ukrainy), opcjonalnie dane oferty (wynagrodzenie miesięcznie i godzinowo, rodzaje umów, wymagania), wyszukiwania z ponad 1000 ogłoszeń, monitoring nowych i usuniętych ogłoszeń, numery telefonów firm, powiadomienia w Telegramie, Slacku, Discordzie i WhatsAppie oraz podsumowanie rynku pracy. Bez proxy. Eksport do Excela, CSV lub JSON.

### Why use this OLX Praca scraper?

- 💰 **Salaries you can compare.** `salaryMin`/`salaryMax` as the ad gives them (per month or per hour), gross or net (`salaryKind`), negotiable or not; with **Job data** also `salaryMonthlyMin/Max` and `salaryHourlyMin/Max` (standard full-time hours) and one readable line (`salaryText`).
- 🧭 **Every search complete with Deep search.** The website shows 1 000 ads per search; the add-on divides bigger searches by itself, and the status message and the SUMMARY record say how many parts were read and whether anything could not be reached.
- 🔎 **The website's own filters** (filtered-out ads cost nothing): category, voivodeship, town and distance, working time, contract type, workplace (on site, remote, hybrid), experience, availability (shifts, weekends, flexible), special requirements (sanitary card, student status…), CV required, management positions, online recruitment, seniors welcome, open to workers from Ukraine, Polish not required, companies or private persons, and any other filter of the website through **Extra website filters**.
- 🧮 **Plus filters the website doesn't have:** salary from / up to (per month), only ads with a salary, posted or refreshed in the last N days or minutes, posted between two dates, words the title or the text must (not) contain, excluded companies, no shift work, and your own rules on any output field.
- 🏷️ **Job parameters as fields (Job data):** working time, Polish contract types (umowa o pracę, zlecenie, o dzieło, samozatrudnienie, staż), experience, availability, shift work (also found in the text), driving licences, special requirements, country for jobs abroad, and the rest under the website's labels in `attributes`.
- 🏢 **Employers, not people.** `company` for business accounts (with logo, their own text and `advertiserId`, which reads all ads of one employer), `advertiserType` business / private.
- 📊 **Market summary for free** (SUMMARY record): median and quartiles of monthly salaries overall and by category, voivodeship, town, working time, contract type and gross/net, top companies, share of private advertisers, and for every search the website's own number of ads.
- 📬 **Monitoring mode:** a feed of new and changed ads (`changeType`, `changedFields`, `previousValues`), optionally **removed ads** (`expired` or `noLongerMatches`, with `daysOnline`) and reappeared ones, a silent first run, stop at known ads for frequent runs, only new ads, ignored fields.
- 🔁 **Reposts under control:** an ad published again under a new number is marked (`isRepost`, `repostOf`) or skipped for free; `contentHash` is the fingerprint.
- 🔔 **Job alerts without any integration:** Slack, Discord, Telegram, WhatsApp or your own webhook (Zapier, Make, n8n) after each run.
- 🤖 **Small rows for AI agents:** **Compact output**, **Leave out empty fields**, or exactly the **Output fields** you list; description as plain text, Markdown or clean HTML, with a length limit.
- 📞 **Phone numbers of business ads (optional):** the number behind the website's "show phone" button, for company accounts only, charged only when returned.
- ⚡ **Fast and light:** no proxy needed, 256 MB of memory; about 1 500 ads a minute (6 000 in fast mode).
- 🔒 **Privacy first:** see [Contacts and personal data](#contacts-and-personal-data).

### What data can you get?

| Group | Fields |
|---|---|
| Ad | `id`, `jobId`, `url`, `title`, `description`, `descriptionSnippet`, `descriptionLength`, `contentHash`, `status`, `postedAt`, `updatedAt` (last refresh), `validThrough` |
| Employer | `company`, `companyLogoUrl`, `companyAbout`, `advertiserType`, `advertiserId`, `advertiserSince`, `advertiserLastSeenAt` (business accounts only); `companyUrl`, `companyVerified` for job URLs |
| Place | `location` (town), `district`, `region` (voivodeship), `country`, `gpsLat`, `gpsLon`, `gpsRadiusKm`, `locationApproximate`, `cityId`, `regionId` |
| Salary | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryKind`, `salaryNegotiable` |
| Raw parameters | `params`: every parameter of the ad as the website gives it (key, label, value, codes), `categoryId`, `categoryType` |
| **Job data (add-on)** | `salaryMonthlyMin/Max`, `salaryHourlyMin/Max`, `salaryText`, `category`, `mainCategory`, `categories`, `categoryPath`, `applyUrl`, `applyMethod`, `jobCountry`, `employmentType` (working time), `polishContractTypes`, `contractTypes`, `workArrangement`, `remote`, `workModes`, `experienceRequired`, `availability`, `shiftWork`, `specialRequirements`, `drivingLicenses`, `cvRequired`, `managerial`, `onlineRecruitment`, `seniorFriendly`, `openToUkrainians`, `polishNotRequired`, `attributes` |
| Contact flags | `hasPhone`, `hasChat` |
| Promotion | `isPromoted`, `isHighlighted`, `isUrgent`, `isTopAd`, `promotionOptions`, `partnerCode` |
| Search | `searchQuery`, `position`, `sourceUrl`, `scrapedAt` |
| Monitoring | `changeType`, `changedFields`, `previousValues`, `firstSeenAt`, `isRepost`, `repostOf`, `repostFirstSeenAt`, `lastSeenAt`, `removedAt`, `removedReason`, `daysOnline` |
| Contacts (add-on) | `contactNames`, `contactEmails`, `contactPhones`, `contactUrls` |
| Phone numbers (add-on) | `phoneNumbers`, `phoneSource` |

### How to scrape OLX Praca

1. Type **search keywords** and/or pick **categories**, **voivodeships** or **towns**; or paste a URL of the jobs section with the filters you set on the website.
2. Set **Max jobs** (0 = everything the search has).
3. Run the actor and download the dataset as Excel, CSV, JSON or through the API.

### Use cases

#### Warehouse jobs in Mazowieckie with a salary

```json
{
  "searchQueries": ["magazynier"],
  "regions": ["mazowieckie"],
  "onlyWithSalary": true,
  "includeJobData": true,
  "maxItems": 500
}
```

#### New driver jobs around Wrocław every morning, to Slack

```json
{
  "categories": ["kierowca"],
  "locations": ["Wrocław"],
  "distanceKm": 30,
  "onlyNewOrChanged": true,
  "monitoringKey": "kierowca-wroclaw",
  "skipFirstRun": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxItems": 0
}
```

#### Salary snapshot of the whole jobs section

```json
{
  "maxItems": 0,
  "deepSearch": true,
  "includeJobData": true,
  "compact": true,
  "fastMode": true
}
```

The whole section (about 75 000 ads) is read in parts; the SUMMARY record has the salary quartiles by category and voivodeship.

#### Full-time employment contracts without required experience in production

```json
{
  "categories": ["produkcja"],
  "workingTime": ["fullTime"],
  "contractTypes": ["employment"],
  "experience": "notRequired",
  "minSalary": 5500,
  "includeJobData": true,
  "maxItems": 1000
}
```

#### A search URL from the website

```json
{
  "startUrls": [{ "url": "https://www.olx.pl/praca/kierowca/warszawa/?search%5Bfilter_enum_type%5D%5B0%5D=fulltime" }],
  "maxItems": 200
}
```

#### Ads that disappeared (how long a position stays open)

```json
{
  "categories": ["gastronomia"],
  "regions": ["pomorskie"],
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "gastro-pomorskie",
  "deepSearch": true,
  "maxItems": 0
}
```

#### All ads of one employer

```json
{
  "advertiserIds": ["1277182495"],
  "maxItems": 0
}
```

#### Website filters (applied by OLX)

Categories, voivodeships, towns and distance, working time, contract types, workplace, experience, availability, special requirements, advertiser type, CV, the check boxes (management, online recruitment, seniors, Ukraine, Polish not required) and **Extra website filters** are applied by the website itself, so the ads they leave out cost nothing. Each keyword, category, place and advertiser is its own search; the values of one filter mean "any of them".

#### Filters (applied by the actor)

The website has no salary or date filter for jobs, so the actor applies **Salary from / up to** (per month in PLN, hourly rates at standard full-time hours), **Only jobs with a salary**, the date filters, the keyword filters, **Exclude companies**, **Exclude shift work** and **Custom filters** to the ads it reads. Filtered-out ads are not charged as jobs; when a filter keeps few ads of many pages, the pages are charged as **Extra page** (see pricing). With **Sort by: newest** a date filter also makes the run shorter. With **Max jobs** of 1 000 or less the filters are applied to the first 1 000 ads of each search (the status message says when that was not enough); set it to 0 or above 1 000 to filter the whole search.

#### Searches with more than 1 000 ads

The website's search never shows more than 1 000 ads, and without the add-on the actor reads those (the status message says when a search had more). With **Deep search**, when a search has more and you ask for more than 1 000 (or for everything), the actor reads it in full automatically, in parts that together cover the whole search, and no ad is read twice. The status message says e.g. "1 search with more than 1 000 ads read in 16 parts"; if any ads could not be reached, it says how many (we have not seen it happen). **Sort by** then orders the ads within each part. The add-on has no price of its own: you pay its small extra cost as **Extra page** (a category with 1 634 ads cost 8 extra pages, $0.0024).

#### Monitoring mode explained

With **Monitoring: only new or changed jobs** the actor remembers the ads of a Monitoring key and saves only what is new or changed since the previous run: a change of the title, company, salary, town, working time, contract types, workplace or the text of the ad (`contentHash` changes). A refresh (bump) of an ad is not a change. `changedFields` and `previousValues` say what changed. Unchanged ads are not saved and not charged; every search page read is charged as **Monitoring page**.

- **Include removed jobs:** ads of the previous run that are gone, as rows with `changeType` "removed", `removedReason` and `daysOnline`; an ad that returns is "reappeared". Only when the run read every search completely.
- **Silent first run:** the first run only remembers; you get rows from the second run on.
- **Stop at known ads:** for frequent runs (every 15 minutes): reads only the newest ads, up to the ones it already knows.
- **Only new jobs**, **include unchanged jobs**, **skip reposted jobs**, **ignore changes in**, **start again**: see the input descriptions.

#### Contacts and personal data

**Default: no personal data.** Ads of private persons (about a quarter) have `company` null, no account data and no map point, and the person's name is replaced with `[employer]` in the title and text. A business account named like a person ("Anna Nowak" without a company name) is treated the same way. E-mails and phone numbers are replaced with `[e-mail removed]` / `[phone removed]` in every title and description, in all formats.

**The option.** **Contacts (personal data, extra charge)** adds, for ads of business accounts only:

| Field | What it has |
|---|---|
| `contactNames` | The contact person the ad names (the account's display name when it is a person's name) and names written next to an e-mail or phone in the text |
| `contactEmails` | E-mail addresses written in the ad |
| `contactPhones` | Phone numbers written in the ad, as `+48XXXXXXXXX` |
| `contactUrls` | Web links written in the ad |

In our sample of **1 599 ads (Opolskie, 2026-11-11)**, 14 % of the business ads had at least one contact (a contact person 9 %, a phone number in the text 5 %, an e-mail 1 %); the website does not allow links in ads, so `contactUrls` is almost always empty.

**Why it is an option with a surcharge.** Contacts are personal data most users do not need; keeping them off by default keeps the default output free of personal data. Only a saved ad that has at least one contact pays the **Contact details** event.

**Your responsibility.** A name, e-mail or phone number of a person is personal data. When you turn the option on, you decide why and how the data is used: you are the controller under the GDPR and need a lawful purpose (for example answering the ad), must inform the people where the law requires it and respect their objections. Private persons never get contacts; contacts are never written to the log or sent in notifications; people who objected are left out.

#### Phone numbers

Most ads have a phone number that the website shows only after a click on "show phone" (`hasPhone` says which). The website limits these lookups. **By default the actor does not read these numbers**; when ads with one were saved, the status message says how many.

**The option.** **Phone numbers behind "show phone"** tries to read them, within these fixed limits:

- **Business advertisers only.** A private person's number is personal data of an individual, and the actor does not collect it, whatever the input says. An account the actor cannot tell from a private person is treated as private.
- **How:** without logging in, through the Apify residential proxy (Poland), at the normal speed. The actor never solves a challenge or a captcha. An ad whose number the website does not give is saved without it and is never asked again from another IP address; after a few refusals in a row, the actor stops reading numbers for the rest of the run and says so.
- **Limits:** at most **Max phone lookups per run** (500 by default, 2 000 at most); the account needs access to the residential proxy group, otherwise the run is refused before it starts.
- **Output:** `phoneNumbers` (as `+48XXXXXXXXX`) and `phoneSource: "button"`. Numbers are never written to the log, the notifications or the description.
- **Price:** the **Phone number** event, only for a saved ad whose number was returned. Lookups that give nothing cost you nothing.
- **Measured (2026-11-11, 3 runs on Apify):** 26 lookups, 26 numbers returned. It was a small sample at a low volume; with hundreds of lookups in a run expect the website to refuse a part of them, and you pay only for the returned ones.

**Your responsibility.** These are contact data that advertisers publish for job applicants. You decide why and how you use them and are the controller under the GDPR: you need a lawful purpose, must respect objections, and must not use them for unsolicited marketing where that is prohibited.

#### Market summary (SUMMARY)

Every run writes a free `SUMMARY` record to the key-value store: the number of ads, the share with a salary, the monthly salary median and quartiles in PLN overall and by gross/net, period, category, voivodeship, town, working time and contract type, the top 20 companies, the share of private advertisers, voivodeships, and for every search the website's own number of ads, the number of parts it was read in and the ads read. The parts by category, working time, contract type and workplace are filled with **Job data**. In monitoring mode it covers the unchanged ads too.

#### Notifications (job alerts)

Fill in a **Slack** or **Discord** webhook URL, a **Telegram** bot token with a chat ID, a **WhatsApp** access token with your business phone number ID and the recipient's number, or any HTTPS **webhook URL**, and every run sends one message per channel: the number of saved ads and up to **max jobs per message** of them (title, company, town, salary, link), with links to the run and the dataset. The webhook gets the same as JSON. Descriptions and contacts are never sent, and the URLs and tokens are stored encrypted and never logged. A run that saved nothing sends nothing.

**WhatsApp:** the WhatsApp Cloud API of your Meta business account: access token, phone number ID, up to 5 recipient numbers and an approved message template, so that the message arrives at any time (without a template only within 24 hours of the recipient's last message). Step by step in [WhatsApp notifications: setup](#whatsapp-notifications-setup).

**E-mail, Teams and others:** point the **webhook URL** at an automation tool (Make, Zapier, n8n, Pipedream) and let it forward the JSON.

#### Fast mode (optional, small extra charge)

Fast mode reads up to about 4× faster (about 6 000 ads a minute instead of 1 500) and drops back to the normal speed for the rest of the run at the first sign of load. It never changes IP address to get around a limit.

### How much does it cost to scrape OLX Praca?

This actor uses pay-per-event pricing: a base price per saved ad, and add-ons that cost something only when you turn them on. Prices per 1 000 on the free plan (the **Pricing** tab has the current ones and the plan discounts):

| Event | Price | What you get |
|---|---|---|
| **Job (base row)** | $0.99 per 1 000 ($0.99 / 0.99 / 0.73 / 0.51 by plan) | A saved ad with everything the website gives: text, salary as written, raw parameters, place, dates, advertiser |
| Actor start | $0.005 per run | The start of the run |
| **Job data** (add-on) | $0.20 per 1 000 | The ad parsed: salary per month and hour, contracts, working time, workplace, requirements, category names, application page |
| **Deep search** (add-on) | through Extra page | More than 1 000 ads of one search: you pay its small extra cost as Extra page |
| **Monitoring** (add-on) | $0.30 per 1 000 pages | Only new, changed and removed ads; every search page read (50 ads) is a Monitoring page, unchanged ads are free |
| **Contact details** (add-on) | $0.30 per 1 000 | A saved business ad with a contact person, e-mail or phone written in the ad |
| **Phone number** (add-on) | $5.00 per 1 000 ($0.005 each) | A saved business ad whose number behind "show phone" was returned |
| **Notification** (add-on) | $0.001 per run | One message per channel after a run that saved something |
| **Fast mode** (add-on) | $0.01 per 1 000 | Ads saved while fast mode was on |
| Extra page | $0.30 per 1 000 | Pages beyond what the saved ads explain: a search that finds nothing, a filter that keeps few ads of many pages, Deep search, town look-ups, URLs of ended ads; 3 per page read through a residential proxy you turn on. If the saved ads don't cover a run's cost (e.g. a search with no results), the difference is charged as extra pages; the log says how many. A normal run has none or a few. |

Example bills (free plan):

- **500 ads of a search, base rows:** 500 × $0.00099 + $0.005 = **$0.50**.
- **The same with Job data:** $0.50 + 500 × $0.0002 = **$0.60**.
- **A whole category of 1 634 ads with Deep search and Job data:** 1 634 × $0.00099 + 1 634 × $0.0002 + 8 extra pages × $0.0003 + $0.005 = **$1.95**.
- **A daily monitoring run of a search with 300 ads and 12 new ones, with Job data and a Slack message:** 6 pages × $0.0003 + 12 × ($0.00099 + $0.0002) + $0.001 + $0.005 = **$0.022** a day.
- **200 business ads with phone numbers, 150 of them returned:** 200 × $0.00099 + 150 × $0.005 + $0.005 = **$0.95**.

Filters are free (they only lower the bill), and so are the market summary, compact output and the privacy defaults. Filtered-out ads, skipped reposts and unchanged ads in monitoring mode are not charged. You can set a maximum cost per run; the actor stops when it is reached. The log of every run ends with the add-ons it charged.

### Input example

```json
{
  "searchQueries": ["magazynier"],
  "maxItems": 20
}
```

### Output example

```json
{
  "id": "olx:1109292398",
  "source": "olx.pl",
  "url": "https://www.olx.pl/oferta/praca/kurier-dostawca-CID4-ID1d4tCS.html",
  "jobId": "1109292398",
  "title": "Kurier / Dostawca – praca od zaraz, elastyczne godziny",
  "company": "City Drive",
  "companyLogoUrl": "https://img-resizer.prd.01.eu-west-1.eu.olx.org/img-eu-olxpl-production/1330103415_1_261x203_rev003.jpg",
  "advertiserType": "business",
  "advertiserId": "1277182495",
  "location": "Gdańsk",
  "district": "Śródmieście",
  "region": "pomorskie",
  "country": "PL",
  "gpsLat": 54.35165637,
  "gpsLon": 18.64943946,
  "locationApproximate": true,
  "salaryMin": 6000,
  "salaryMax": 10000,
  "salaryCurrency": "PLN",
  "salaryPeriod": "month",
  "salaryMonthlyMin": 6000,
  "salaryMonthlyMax": 10000,
  "salaryHourlyMin": 37.5,
  "salaryHourlyMax": 62.5,
  "salaryKind": "gross",
  "salaryNegotiable": false,
  "salaryText": "6 000–10 000 PLN / month gross",
  "employmentType": ["temporary"],
  "polishContractTypes": ["mandate"],
  "contractTypes": ["workAgreement"],
  "experienceRequired": false,
  "availability": ["flexible"],
  "onlineRecruitment": true,
  "openToUkrainians": true,
  "polishNotRequired": true,
  "category": "Dostawca, kurier miejski",
  "mainCategory": "Dostawca, kurier miejski",
  "categoryPath": "praca/dostawca-kurier-miejski",
  "description": "Czym jest praca kuriera? …",
  "applyUrl": "https://kariera.example.com/kurier",
  "applyMethod": "external",
  "hasPhone": true,
  "postedAt": "2026-11-02T09:59:39Z",
  "updatedAt": "2026-11-09T12:20:46Z",
  "validThrough": "2026-12-02T09:59:39Z",
  "isPromoted": true,
  "searchQuery": "kurier",
  "position": 1,
  "sourceUrl": "https://www.olx.pl/praca/q-kurier/",
  "scrapedAt": "2026-11-11T18:00:00Z"
}
```

(Shortened: the row has more fields, see the dataset schema. This row is with **Job data**; a base row has the same ad with `params` (the raw parameters) and with the parsed fields such as `salaryMonthlyMin`, `employmentType`, `polishContractTypes`, `category` or `applyUrl` empty.)

### Limitations

- **About half of the ads have a salary.** Measured on 1 599 ads (all jobs in Opolskie, 2026-11-11): salary 54 % (73 % of them per month, 27 % per hour, all in PLN and gross), title, description, town, voivodeship, category, working time, contract type, experience and dates 100 %, `company` 53 % (67 % of the ads of business accounts; the others are private persons or accounts named like a person or with a name like "HR"), a map point 53 %, workplace 41 %, availability 48 %, `applyUrl` 27 %, district 5 %. 79 % of the ads were from business accounts.
- **Salaries are as the advertiser typed them.** With **Job data**: a few are entered with the wrong period (an hourly rate as a monthly salary, under 1 % in the sample): they are shown as on the website, but `salaryMonthly*` and `salaryHourly*` stay null. Hourly and monthly equivalents use standard full-time hours.
- **One search shows 1 000 ads**; with **Deep search** bigger searches are read in parts (see above) at a small extra cost. **Sort by** orders within a part, and `position` is the position within the part.
- **Promoted ads** come at fixed places of every page outside the search order (`isPromoted`); each is saved once.
- `companyUrl`, `companyVerified`, `streetAddress` and `postalCode` are only on the job page, so they are filled only for ads given by their URL. When the website rejects the job page of a job URL, the ad is found in the website's search (the same ad ID) and saved with the data of the search, without these four fields.
- The map point is the area the website shows (usually approximate, `locationApproximate`).
- `shiftWork` is also found in the ad's text, so it can be an estimate; `shiftWorkSource` says where it comes from.
- `isRepost` compares with the ads of earlier runs with the same Monitoring key; the first run has nothing to compare with.
- Removed ads are found only when the run read every search completely (no limits, date filters or unread pages).
- Free text may still name a person: e-mails and phone numbers are removed, names inside the text are not (except the private advertiser's own name).
- Polish OLX only (olx.pl), jobs section only. A town name the website does not know is reported.
- No proxy needed. A search 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. It never solves captchas or other challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/olx-praca-scraper").call(run_input={
    "searchQueries": ["kierowca C+E"], "regions": ["slaskie"], "onlyWithSalary": True, "includeJobData": True,
    "maxItems": 200, "compact": True,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["location"], job["salaryMonthlyMin"], job["salaryMonthlyMax"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["salary"]["monthly"], summary["salary"]["byCategory"])
```

Apify's MCP server (mcp.apify.com) exposes the actor as a tool for AI agents; **Compact output**, **Leave out empty fields** and **Output fields** keep the rows small for a model's context.

### Troubleshooting

- **"no jobs: …"**: the website found nothing for that search; check the keyword and the filters.
- **"Town not found"**: write the town as on the website (`Zielona Góra`), add the voivodeship for a common name, or use **City IDs**.
- **"The website refused the search"**: a filter in **Extra website filters** or in a pasted URL does not exist in that category; the message quotes the website.
- **"rejecting requests"**: try again later; if it keeps happening, set **Proxy configuration** to Apify Proxy with the RESIDENTIAL group and country Poland (requests through it cost extra).
- **Fewer jobs than expected**: check the filters summary in the status message ("filtered out: …").

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

### FAQ

#### Is it legal to scrape OLX Praca?

It reads only publicly available data, without logging in, at most 30 requests per minute (120 in fast mode), slows down when the website asks and never solves captchas or other challenges. By default it returns no personal data: private advertisers' names are hidden and e-mails and phone numbers are removed from the texts; it returns contacts of business advertisers only if you turn on **Contacts (personal data)**, and then you are responsible for using them lawfully. The website's terms of use may restrict extracting its data; you are responsible for how you use the data (GDPR, database rights and the website's terms). If in doubt, ask a lawyer. This actor is not affiliated with OLX.

#### How does it get more than 1 000 ads of a search?

With the **Deep search** add-on, by reading the search in parts that the website can show completely, see [Searches with more than 1 000 ads](#searches-with-more-than-1-000-ads).

#### Why is the company empty for some jobs?

The ad is from a private person, or from a business account that has only a person's name or a name like "HR" and no company name. Such names are personal data or say nothing, so `company` is null; `advertiserType` tells the two apart.

#### Can I get phone numbers?

Numbers written in the text of ads of business accounts come with **Contacts**. The number behind the website's "show phone" button is read only with **Phone numbers behind "show phone"**, for business ads only, and the website serves only some of the lookups (see [Phone numbers](#phone-numbers)).

#### How are salaries converted?

`salaryMin` and `salaryMax` are the amounts of the ad for its period (`month` or `hour`). With **Job data**, `salaryMonthly*` and `salaryHourly*` convert between the two at standard full-time hours. Almost all amounts are gross (`salaryKind`).

#### Do I need a proxy?

No proxy needed.

#### Can I scrape other sections of OLX or other countries?

No, this actor is for the jobs section of olx.pl; its fields, filters and the division of big searches are built for job ads.

#### Can I use it from an AI agent or through MCP?

Yes, through Apify's MCP server (mcp.apify.com); no separate connector is needed.

***

Also known as an OLX Praca API, OLX jobs scraper, olx.pl job ads export or Poland blue-collar jobs and salary data (Polish: "oferty pracy OLX", "ogłoszenia o pracę OLX", "praca OLX", "praca sezonowa", "wynagrodzenia").

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/olx-praca-scraper/changelog.md

# Actor input Schema

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

Words to search for, as typed into the search box of the jobs section, e.g. "magazynier", "kierowca C+E", "opiekunka". The website searches the title and the text of the ads. Each line is a separate search, combined with the categories, places and website filters below. Empty = all job ads that match the rest.

## `categories` (type: `array`):

Categories of the jobs section (140: 42 main ones, their subcategories and the website's 5 selections such as "Praca dodatkowa"). Each chosen category is a separate search. Empty = the whole jobs section. Applied by the website.

## `regions` (type: `array`):

Only ads in these voivodeships (each is a separate search). Applied by the website.

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

Towns by name, e.g. Warszawa, Kraków, Zielona Góra (the website's own place search finds them; for a name that several places share, add the voivodeship: "Dąbrowa, opolskie"), or voivodeships by name. Each line is a separate search. A town that the website does not know is reported in the status message.

## `distanceKm` (type: `integer`):

Also ads within this many kilometres of each town (e.g. 5, 10, 15, 30, 50, 75 and 100). 0 = the town only.

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

Search and category URLs of the jobs section, with any filters set on the website (e.g. https://www.olx.pl/praca/kierowca/warszawa/ or https://www.olx.pl/praca/q-magazynier/), and URLs of job ads (https://www.olx.pl/oferta/praca/…-ID….html). A search URL keeps its own filters and place (the website filters below are not added to it; the actor's filters are). URLs of other sections of OLX are skipped.

## `advertiserIds` (type: `array`):

All job ads of these business advertisers: the advertiserId of a row of this actor (e.g. 1277182495). Each is a separate search, combined with the keywords, categories and places.

## `includeJobData` (type: `boolean`):

Adds the parsed job fields to every row: salary per month and per hour and as one line, working time, contract types, workplace (remote, hybrid, on site), experience, availability, shift work, driving licences, special requirements, the check boxes (CV, management, online recruitment, seniors, Ukraine, Polish), category name and path, country for jobs abroad, the employer's application page and the other parameters under their labels. Off = these fields are empty.

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

Maximum number of job ads saved. You pay per saved ad. 0 = no limit (the jobs section has about 75 000 ads).

## `maxItemsPerSearch` (type: `integer`):

Limit for each keyword, category, place or URL separately, so one large search doesn't use up the whole Max jobs. 0 = no limit.

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

Read at most this many pages (50 ads each) of every search. 0 = no limit.

## `deepSearch` (type: `boolean`):

The website shows at most 1 000 ads of one search, and by default the actor reads those. With this add-on a bigger search is read in parts that together cover it, so a whole category or the whole jobs section fits in one run. It needs "Max jobs" above 1 000 or 0. Its small extra cost is paid as "Extra page" (see Pricing).

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

Order of the website's search. With a limit you get the first ads in this order. With "Deep search" the ads are ordered within each part.

## `workingTime` (type: `array`):

Only ads with one of these working times.

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

Only ads that offer one of these contracts.

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

Only ads with one of these workplaces (many ads do not say).

## `experience` (type: `string`):

Only ads that do or do not require experience.

## `availability` (type: `array`):

Only ads marked with one of these.

## `specialRequirements` (type: `array`):

Only ads marked with one of these.

## `advertiserType` (type: `string`):

Only ads of companies or only ads of private persons (about a quarter of the ads; their names are never returned).

## `cvRequired` (type: `string`):

Only ads that do or do not require a CV.

## `managerial` (type: `boolean`):

Only ads marked "Kadra kierownicza".

## `onlineRecruitment` (type: `boolean`):

Only ads marked "Rekrutacja online".

## `seniorFriendly` (type: `boolean`):

Only ads marked "Zapraszamy seniorów".

## `openToUkrainians` (type: `boolean`):

Only ads marked as welcoming workers from Ukraine.

## `polishNotRequired` (type: `boolean`):

Only ads marked "Jęz. polski niewymagany".

## `extraFilters` (type: `object`):

Any other filter of the website, passed as it is, e.g. {"filter_enum_driving_license": \["catce"], "filter_enum_transport_range": \["international_transport"]} in the category Kierowca, or {"filter_enum_country_job": \["d"]} in Praca za granicą. The names are the ones in the website's search URLs (search\[filter_enum\_…]). A filter the category does not have is refused by the website and reported.

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

Skip ads without a salary (about half of the ads).

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

Only ads whose salary reaches at least this much per month (hourly rates are converted at standard full-time hours). Ads without a salary are left out. The filter works with or without "Add job data".

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

Only ads whose salary starts at this much per month or less. Ads without a salary stay.

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

Only ads first posted in the last N days. With "Sort by" = newest the run stops reading at older ads.

## `refreshedWithinDays` (type: `integer`):

Only ads posted or refreshed (bumped) in the last N days.

## `maxAgeMinutes` (type: `integer`):

Only ads posted or refreshed in the last N minutes, for frequent scheduled runs.

## `postedFrom` (type: `string`):

Only ads first posted on this day or later (YYYY-MM-DD).

## `postedTo` (type: `string`):

Only ads first posted on this day or earlier (YYYY-MM-DD).

## `titleKeywords` (type: `array`):

Only ads whose title has these words (without diacritics and case).

## `descriptionKeywords` (type: `array`):

Only ads whose title or description has these words, e.g. "zakwaterowanie", "umowa o pracę".

## `keywordsMode` (type: `string`):

For "Title must contain" and "Text must contain".

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

Skip ads whose title has any of these words.

## `excludeDescriptionKeywords` (type: `array`):

Skip ads whose title or description has any of these words.

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

Skip ads of companies whose name has any of these words (e.g. agencies).

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

Skip ads marked as shift work or whose text says so (see the shiftWork field).

## `customFilters` (type: `array`):

Rules on any output field, all must hold: \[{"field": "salaryMonthlyMin", "op": "gte", "value": 6000}, {"field": "polishContractTypes", "op": "includes", "value": "employment"}]. Operators: includes, notIncludes, equals, notEquals, gt, gte, lt, lte.

## `skipJobsFromDataset` (type: `string`):

Run ID or dataset ID of an earlier run of this actor: ads it saved are left out (and not charged), e.g. to continue a run that stopped at a limit.

## `includeContacts` (type: `boolean`):

Add contactNames, contactEmails, contactPhones and contactUrls to ads of business advertisers.

## `includePhoneNumbers` (type: `boolean`):

Tries to read the phone number the website shows after a click, for ads of companies (business accounts) only; never for private persons. The lookups go through the Apify residential proxy (Poland) at the normal speed, and the website serves only some of them: you pay "Phone number" only for an ad whose number was returned (see Pricing and "Phone numbers" in the README). You are responsible for using the numbers lawfully.

## `maxPhoneNumbers` (type: `integer`):

At most this many business ads are looked up in one run (hard maximum 2 000); the other ads are saved without a number.

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

Format of the description. E-mails and phone numbers are removed from it in every format.

## `descriptionMaxLength` (type: `integer`):

Cut descriptions to about this many characters. 0 = whole descriptions.

## `compact` (type: `boolean`):

Keep only the core fields of every row: id, title, company, town, voivodeship, salary, working time, contract, category, dates, link (and the monitoring fields). Smaller rows for AI agents, MCP clients and dashboards; the price per ad is the same.

## `excludeEmptyFields` (type: `boolean`):

Drop fields that are null or empty from every row (the columns then differ between rows).

## `fields` (type: `array`):

Keep only these fields in every row (plus id, source, url, title, scrapedAt), e.g. company, location, salaryMonthlyMin, salaryMonthlyMax, postedAt. Empty = all fields.

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

Save only ads that are new or changed since the previous run with the same Monitoring key (changed = title, company, salary, town, working time, contract, workplace or the text of the ad). Unchanged ads are free; each search page 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 ads that were in the previous run and are gone, as rows with changeType "removed" and removedReason "expired" (the ad ended) or "noLongerMatches" (the ad is live but no longer in the search), with daysOnline; an ad that comes back is "reappeared". At most 300 gone ads are checked per run. Checked only when the run reads every search completely (limits, date filters, unread pages or rejected requests skip the check, and the status message says why). Removed rows are charged like any other job.

## `includeUnchanged` (type: `boolean`):

Also return the ads that did not change, as rows with changeType "unchanged". They are saved rows, so each is charged like any other job; without this option unchanged ads are free.

## `onlyNew` (type: `boolean`):

Return only ads the earlier runs have not seen; changed ads are remembered but not returned.

## `skipReposts` (type: `boolean`):

Do not return a new ad that is the same ad seen in an earlier run under another ID (the advertiser published it again). Skipped ads are not charged. Off = such ads are returned with isRepost true, repostOf and repostFirstSeenAt.

## `skipFirstRun` (type: `boolean`):

The first run with a Monitoring key only remembers what is on the website and returns nothing (no rows are charged, only the pages read); the following runs return what is new since then.

## `monitoringEarlyStop` (type: `boolean`):

With "Sort by" = newest: stop reading a search at the first page whose ads are all known and unchanged, so a frequent run reads only the newest ads instead of the whole search. Changes of older ads are then not seen, and it cannot be combined with "include removed jobs".

## `ignoreChangesIn` (type: `array`):

Fields whose change does not make an ad "updated". Changing this list makes every ad "updated" once.

## `resetMonitoring` (type: `boolean`):

Forget what the earlier runs with this Monitoring key saw: this run returns everything as new.

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

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

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

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

Categories by the website's numbers (e.g. 1447 = Produkcja, 2445 = Kierowca) or paths ("produkcja/obsluga-produkcji"), added to "Categories".

## `cityIds` (type: `array`):

Towns by the website's numbers (the cityId of a row of this actor, e.g. 17871 = Warszawa), added to "Towns or voivodeships".

## `districtId` (type: `integer`):

A district of the one town you search, by the website's number (search\[district_id] in its URLs).

## `fastMode` (type: `boolean`):

Fast mode reads up to about 4× faster (6 000 ads a minute instead of 1 500) and drops back to the normal speed for the rest of the run at the first sign of load. It never changes IP address to get around a limit. Small extra charge "Fast mode" per saved ad.

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

No proxy needed. If the website starts rejecting the requests, use Apify Proxy with the RESIDENTIAL group and country Poland: every page read through a residential proxy is then charged as 3 extra pages (see Pricing).

## `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
{
  "searchQueries": [
    "magazynier"
  ],
  "distanceKm": 0,
  "includeJobData": false,
  "maxItems": 20,
  "maxItemsPerSearch": 0,
  "maxPagesPerSearch": 0,
  "deepSearch": false,
  "sortBy": "newest",
  "experience": "any",
  "advertiserType": "any",
  "cvRequired": "any",
  "managerial": false,
  "onlineRecruitment": false,
  "seniorFriendly": false,
  "openToUkrainians": false,
  "polishNotRequired": false,
  "onlyWithSalary": false,
  "keywordsMode": "any",
  "excludeShiftWork": false,
  "includeContacts": false,
  "includePhoneNumbers": false,
  "maxPhoneNumbers": 500,
  "descriptionFormat": "text",
  "descriptionMaxLength": 0,
  "compact": false,
  "excludeEmptyFields": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "includeUnchanged": false,
  "onlyNew": false,
  "skipReposts": false,
  "skipFirstRun": false,
  "monitoringEarlyStop": false,
  "resetMonitoring": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "fastMode": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

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

No description

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

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

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

```

## MCP server setup

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