# NoFluffJobs Scraper ($0.59/1K): Polish IT Jobs & Salaries (`tsutseisoftware/nofluffjobs-scraper`) Actor

Scrape NoFluffJobs job offers: salary per month and hour, contract type (B2B, employment), company, towns, work mode, seniority, category and technologies. One row per offer, website filters, optional job details, monitoring of new and removed offers, IT market summary. Unofficial. Oferty pracy IT.

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

## Pricing

from $0.42 / 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

## NoFluffJobs Scraper: IT Jobs & Salaries (Poland, CZ, SK, HU)

Get job offers from **NoFluffJobs** (nofluffjobs.com), the Polish IT job board known for showing salaries, as clean, ready-to-use data. Search by **keywords**, **categories**, **seniority**, **technologies**, **towns** (or remote), **contract type** (B2B, employment contract, mandate contract), **companies** and **minimum salary**, or paste any NoFluffJobs search URL. For each offer you get the title, company with logo, all its towns with GPS, **work mode** (remote, hybrid, on site), **salary per month and per hour**, salary kind (B2B net + VAT or gross), contract type, seniority, category, main technologies and the posting and renewal dates.

**One row per offer, not per town.** The website lists an offer once for every town, and a remote offer once for every voivodeship: about 21 000 records for about 3 500 real offers. The actor merges them, so you never pay for the same offer several times, and `locations` and `offerUrls` list all its towns.

**Cheap by default.** Salaries come without job pages, so the default run is cheap: **$0.59 per 1 000 offers**, $0.64 with the description and details. No proxy and no browser needed. Turn on **Add description and details** when you also want the description, daily tasks, requirements, all skills, benefits and the salary of every contract type in its original currency.

Built for **watching the IT job market**: schedule it daily in monitoring mode and you get only offers that are new or changed, plus, if you want, the offers that **disappeared** with the number of days they were online. Every run also saves a free **market summary**: salary quartiles by seniority, category, town and contract kind, top companies and top technologies.

The output uses the same field names and values as our **Pracuj.pl**, **Jobs.cz**, **Prace.cz**, **StartupJobs.cz** and **Profesia** scrapers, so the data can go into one table.

> **Po polsku:** Scraper i API ofert pracy IT z **No Fluff Jobs** (nofluffjobs.com): pobiera widełki wynagrodzeń miesięcznie i godzinowo (B2B netto + VAT lub brutto na umowie o pracę), firmę, miasta z GPS, tryb pracy (praca zdalna, hybrydowa lub stacjonarna), rodzaj umowy, poziom stanowiska, kategorię i technologie. Jedna oferta to jeden wiersz, a nie osobny wiersz dla każdego miasta. Filtry serwisu, także wersje dla Czech, Słowacji, Węgier i Ukrainy, opcjonalnie opis i szczegóły oferty, porównanie wynagrodzenia z rynkiem, monitoring nowych i usuniętych ofert, powiadomienia w Telegramie, Slacku, Discordzie i WhatsAppie oraz podsumowanie rynku pracy IT. Bez proxy. Eksport do Excela, CSV lub JSON.

### Why use this NoFluffJobs scraper?

- 💰 **Salaries you can compare.** `salaryMin`/`salaryMax` per month in PLN (or EUR, USD, CZK, HUF, GBP, CHF, UAH), the hourly, daily and yearly equivalents, the salary kind (`netPlusVat` for B2B, `gross` for employment contracts) and when the employer tells the salary if the offer does not show it (`salaryDisclosure`).
- 🧾 **Salary of every contract type** (with details): an offer with a B2B rate and an employment salary has both, each as the website shows it per month **and** as the employer gave it ("40–45 USD per hour", "82 000–140 000 EUR per year").
- 🧩 **One offer = one row.** Towns of the same offer are merged (`locations`, `offerUrls`), so 3 500 offers are 3 500 rows, not 21 000. If you need it, **One row per: Town** gives a row for every town instead.
- 🔎 **The website's own filters** (filtered-out offers cost nothing): 37 categories, seniority, technologies, towns and remote, contract type, companies, minimum salary, ad language (e.g. English-only offers), and the regional versions for Czechia, Slovakia, Hungary and Ukraine.
- 🧮 **Plus filters the website doesn't have:** work mode, only offers with a salary, salary up to, posted in the last N days, title must (not) contain, exclude companies.
- 🎯 **Salary benchmark per offer (optional):** how every offer stands against the market of the same salary kind, category and seniority (and town): median and quartiles, `salaryVsMarketPercent`, percentile, an estimated range for offers that show no salary, and the employer's number of open offers.
- 🧠 **Skills you can group by:** `technologiesNormalized` merges aliases ("JS" → JavaScript, "k8s" → Kubernetes, "Postgres" → PostgreSQL); the website's spelling stays in `technologies`.
- 📈 **Signals nobody else returns:** days online, how many times the ad was renewed (`renewCount`), the ad package the employer paid for (`adPackage`), and in monitoring the previous salary and its change in percent.
- 📊 **Market summary for free** (SUMMARY record): salary median and quartiles overall and by kind, seniority, category, town and voivodeship, top companies, top 30 technologies, work modes and contract types.
- 📬 **Monitoring mode:** a daily feed of new and changed offers (`changeType`), optionally with **removed offers** (`expired` or `noLongerMatches`, with `daysOnline`). Small daily currency-rate moves are not reported as a change.
- 🔁 **Reposts and unchanged offers under control:** an ad published again under a new reference is marked (`isRepost`, `repostOf`) or skipped; unchanged offers can be returned too when you need the full list every day.
- 🌍 **Several regions in one run** (Poland, Czechia, Slovakia, Hungary, Ukraine), each offer saved once, all salaries in one currency.
- ↕️ **Sorting the website doesn't have:** newest first, recently renewed first, highest or lowest salary first.
- 🏢 **Company profile (optional):** founding year, industries, website and social profiles, offices, technologies, values, recruitment stages; read once per company per run.
- 🔔 **Job alerts without any integration:** send the saved offers to **Slack, Discord, Telegram, WhatsApp** or your own **webhook** (Zapier, Make, n8n) after each run; with monitoring only the new and changed ones.
- 📝 **How to apply and what the recruitment looks like** (with details): the employer's own application page (`applyUrl`), recruitment steps and languages, language levels (`C1`), methodology (Scrum, code review…), equipment and operating systems, office perks, remote scale 0–5.
- 🤖 **Small rows for AI agents:** **Compact output** keeps the core fields, **Leave out empty fields** drops nulls and empty lists.
- ✅ **Complete, not "about 97 %":** when a search is read in full, the actor checks it against the website's own count and adds any offers missed while the list was changing; the log shows both numbers.
- ⚡ **Fast and light:** no browser, no proxy, 256 MB of memory. The whole Polish version without details takes about two and a half minutes (under a minute in fast mode).
- 🔒 **Privacy first.** No contacts unless you turn them on (**Contacts**, a paid option, see below); e-mails and phone numbers inside texts are always replaced with `[e-mail removed]` / `[phone removed]`, and employers named like a private person are hidden.

#### How it compares with other NoFluffJobs scrapers

An honest comparison with the other NoFluffJobs scrapers in the Store (checked 2026-11-11), without naming them:

| Capability | This actor | Other scrapers |
|---|---|---|
| Search, filters, URLs, regions, details, salary per contract type | yes | the better ones too |
| Monitoring of new and changed offers, notifications, compact output | yes | a few |
| Removed offers with the reason and days online, reposts as a field, salary change history | yes | removed offers in two, the rest in none |
| One row per offer **or** per town, several regions in one run, exact sorting | yes | each in one or two |
| **Salary benchmark per offer** (market median, percentile, estimate for offers without a salary) | yes (option) | none |
| **Market report in every run** (salary quartiles, technology demand with median salaries, B2B against employment, hiring signals per company) | yes, free | none (one separate paid report actor covers salaries only) |
| Normalised skills, times renewed, ad package, days online | yes | none |
| Company profile | yes (option, charged once per company) | one, charged per row |
| Price per 1 000 offers | among the lowest; details are a small extra | several include details in a higher base price |
| Every offer of a large search (the website's list moves while it is read) | yes: checked against the website's own count, missed offers added | a single pass |
| No run that reads a lot and saves little is free | pages beyond the saved offers are charged as **Extra page** | most charge per saved row only |
| Company e-mails looked up on other websites | no (only what the ad shows) | one does |
| Built-in WhatsApp channel | yes | one does |

### What data can you get?

| Field | Example |
|---|---|
| Title, offer ID, URL | Change Management Specialist, FR4BZUN3 |
| Company, logo | Spyrosoft |
| Towns, voivodeship, country, address, GPS | Wrocław; \["Wrocław", "Brussels", "Spain"]; dolnośląskie; PL; plac Nowy Targ 28; 51.11, 17.04 |
| Work mode | workArrangement `hybrid`, remote `false`, hybridDescription "2x/tydzień w biurze" |
| Salary | 26 208 – 29 400 PLN per month (hourly 163.80 – 183.75, daily 1 310 – 1 470, yearly 314 496 – 352 800), salaryKind `netPlusVat` |
| Contract, seniority, category | polishContractTypes `b2b`; contractTypes `freelance`; seniority `senior`; category `projectManager` |
| Technologies, languages | technologies \["Stakeholder management", "AI"], technologiesNormalized; \["en"] |
| Dates | postedAt, updatedAt (last renewal), daysOnline |
| Flags | onlineInterview, openToUkrainians, isPromoted |
| With **Add description and details** | description (text, Markdown or HTML), daily tasks, requirements, all required and optional skills, benefits, `salaries` per contract type with the original currency and period, company size, website and profile, expiry date, start date; how to apply (`applyMethod`, `applyUrl`), `recruitmentSteps`, `interviewLanguages`, `languageRequirements` with levels, `methodology`, `equipment`, `officePerks`, `remoteLevel`, `remoteFlexible`, `salaryUpperBoundFlexible`, `renewCount`, `adPackage` |
| With **Salary benchmark** | marketSalaryP25Monthly, marketSalaryMedianMonthly, marketSalaryP75Monthly, marketSampleSize, marketBenchmarkLevel, marketSalaryKind, salaryVsMarketPercent, salaryMarketPercentile, estimatedSalaryMinMonthly, estimatedSalaryMaxMonthly, companyOpenOffers, companyNewOffers7d |
| With **Company profile** | `companyProfile`: name, size, foundedIn, industry, industries, website, linkedin, facebook, twitter, instagram, about, video, offices, technologies, specializations, benefits, officePerks, values, recruitmentStages, pressLinks |
| With **Contacts** (personal data) | contactEmails, contactPhones, contactNames |
| With **Monitoring** | previousSalaryMin, previousSalaryMax, salaryChangePercent, isRepost, repostOf, changeType, firstSeenAt, changedFields; removed offers with removedReason, removedAt, lastSeenAt, daysOnline; reappeared |

### How to scrape NoFluffJobs

1. Choose **what** to scrape: search keywords, categories and the website filters, or paste NoFluffJobs search or job URLs. When the website rejects the job page of a job URL, the offer is found in the website's search (the same job URL) and saved with its list data.
2. Set **Max jobs** (you pay per saved offer) and decide whether you need **Add description and details**.
3. Run the actor and export the dataset to Excel, CSV or JSON, or read it through the API. The market summary is in the key-value store under `SUMMARY`.

### Use cases

#### Python jobs in Warsaw or remote, with a salary

```json
{
  "technologies": ["Python"],
  "locations": ["Warszawa", "Remote"],
  "onlyWithSalary": true,
  "maxItems": 200
}
```

#### New senior backend offers every morning

Schedule it daily; only new and changed offers are returned.

```json
{
  "categories": ["backend"],
  "seniority": ["senior", "expert"],
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "maxItems": 0
}
```

#### B2B rates of DevOps engineers, with the original currency

```json
{
  "categories": ["devops"],
  "contractTypes": ["b2b"],
  "minSalary": 20000,
  "includeDetails": true,
  "maxItems": 100
}
```

#### Salary snapshot of the whole Polish IT market

About 3 500 offers in about two and a half minutes; the SUMMARY record has the quartiles.

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

#### IT offers open to candidates in Czechia, salary in CZK

```json
{
  "region": "cz",
  "salaryCurrency": "CZK",
  "maxItems": 500
}
```

#### English-only offers, alert to Slack every morning

Schedule it daily; the new offers come to your Slack channel (title, company, town, salary, link).

```json
{
  "jobLanguages": ["en"],
  "locations": ["Remote"],
  "onlyNewOrChanged": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxItems": 0
}
```

#### Small rows for an AI agent

```json
{
  "searchQueries": ["python"],
  "compact": true,
  "excludeEmptyFields": true,
  "maxItems": 30
}
```

#### The 20 newest Java offers in Poland and Czechia, with company profiles

The actor reads the whole search, orders it and saves the newest 20; the profile of each company is read once.

```json
{
  "technologies": ["Java"],
  "regions": ["pl", "cz"],
  "sortBy": "newest",
  "includeDetails": true,
  "includeCompanyProfile": true,
  "maxItems": 20
}
```

#### Which senior backend offers pay above the market?

The whole Polish version is read once for the benchmark, then your search is saved with its position in the market.

```json
{
  "categories": ["backend"],
  "seniority": ["senior"],
  "onlyWithSalary": true,
  "salaryBenchmark": "market",
  "sortBy": "salaryDesc",
  "maxItems": 100
}
```

#### A feed of salary changes

Schedule it daily: only offers whose salary changed come back, with the previous salary and the change in percent.

```json
{
  "categories": ["backend", "devops", "data"],
  "onlyNewOrChanged": true,
  "monitoringFields": ["salaryMin", "salaryMax"],
  "maxItems": 0
}
```

#### Website filters (applied by NoFluffJobs)

**Search keywords** go to the website as typed into its search box: it reads known words as a category, a technology or a town and the rest as keywords, and the run log says how it read them ("the website read the search as requirement: Python"). **Categories**, **Seniority**, **Technologies**, **Towns** (with "Remote"), **Contract types**, **Companies**, **Ad languages** and **Salary from** are the website's own filters; several values of one filter mean any of them. **Region of the website** chooses the Polish, Czech, Slovak, Hungarian or Ukrainian version (the other versions show the offers open to candidates there: about 2 000 for Czechia in November 2026, many of them the same Polish and remote offers). A pasted search URL keeps its own filters.

#### Filters (applied by the actor, you don't pay for filtered-out jobs)

**Work mode**, **Only jobs with a salary**, **Salary up to**, **Posted in the last N days**, **Title must contain**, **Title must not contain**, **Exclude companies**. The status message says how many offers each filter left out.

#### Offers in several towns

An offer in several towns (or a remote offer, shown for every voivodeship) is one row: `location` is its first town, `locations` all of them, `url` the job page of the first town and `offerUrls` the job pages of all towns. A fully remote offer without an office has `location` "Remote" and empty `locations`.

With **One row per: Town** every town of an offer is its own row with its own address, GPS and job URL. The ID is then the offer's ID with the town (`nofluffjobs:FR4BZUN3@wroclaw`, `…@remote` for a fully remote offer), the same in every run, and `jobId` stays the offer's reference, so the rows of one offer can be grouped. Every saved row is charged: an offer in 3 towns costs 3 jobs (and 3 job pages with details). Monitoring keeps a separate state for the two modes, so switching the mode with the same Monitoring key does not return everything as new.

#### Monitoring mode explained

With **Monitoring: only new or changed jobs** the actor remembers the offers of the previous run with the same **Monitoring key** and returns only new offers and those whose title, company, salary, towns, work mode, seniority, contract type or category changed (`changeType`, `changedFields`). A renewal of the ad (`updatedAt`) is not a change, and small daily currency-rate moves are not reported as a change. With **Monitoring: include removed jobs** the offers that left the search come back once as `removed` rows, each checked on the website: `expired` (the ad ended) or `noLongerMatches`. Use a different key for every watched search.

#### Salary benchmark (optional, extra charge)

**Salary benchmark** compares every saved offer with the market and adds:

| Field | Meaning |
|---|---|
| `marketSalaryP25Monthly`, `marketSalaryMedianMonthly`, `marketSalaryP75Monthly` | quartiles of the monthly salary of the comparable offers, in the run's currency |
| `marketSampleSize`, `marketBenchmarkLevel`, `marketSalaryKind` | how many offers the figures come from, which group was used, and the salary kind |
| `salaryVsMarketPercent`, `salaryMarketPercentile` | the offer's salary (middle of its range) against the median (+16 = 16 % above) and the share of comparable offers that pay the same or less |
| `estimatedSalaryMinMonthly`, `estimatedSalaryMaxMonthly` | for an offer that shows no salary: an estimated range from the comparable offers |
| `companyOpenOffers`, `companyNewOffers7d` | the employer's offers in the market, and how many were first published in the last 7 days |

**Comparable offers** have the same salary kind (B2B and employment are never mixed), category and seniority, and the same town when there are enough. `marketBenchmarkLevel` says which group was used. Too few comparable salaries = no benchmark (null), never a guess.

**The market** is your choice:

- **Against the offers of this run's searches:** every offer your searches find (also those your filters or Max jobs leave out), so the searches are read whole first, like with sorting; pages beyond the saved offers are charged as **Extra page**. Best when the search itself is the market you care about ("all Java offers").
- **Against the whole website (read once):** the regional version is read once before the run (2–3 minutes for Poland at the normal speed, under a minute in fast mode) and charged as **Market snapshot** once per region. Best for a narrow search, job URLs, or monitoring runs that save a few new offers.

Only a saved offer that got a benchmark pays the **Salary benchmark** event. In a run of the whole Polish version (2026-11-11) a benchmark was found for 99.9 % of the 3 315 saved offers: 65 % got their position against the market and 34 % (the offers without a salary) an estimated range. If the market cannot be read completely, the run goes on without the benchmark and without these two charges (the pages already read count as extra pages).

#### Unchanged offers and reposts (monitoring)

- **Monitoring: include unchanged jobs** also returns the offers that did not change, as rows with `changeType` "unchanged" (the data of the list; their job pages are not read again). They are saved rows, so **each is charged like any other job**; without the option unchanged offers cost nothing but the Monitoring page fee.
- An updated offer whose salary changed has `previousSalaryMin`, `previousSalaryMax` and `salaryChangePercent` (change of the middle of the range; + = raised). **Monitoring: fields that count as a change** narrows what makes an offer "updated", e.g. only `salaryMin` and `salaryMax` for a feed of salary changes.
- An ad published again under a new reference is recognised across your monitoring runs: such an offer has `isRepost` true and `repostOf` (the ID of the earlier offer). **Monitoring: skip reposted jobs** leaves them out, and skipped offers are not charged.

#### Several regions in one run

**Several regions in one run** reads the chosen versions of the website (pl, cz, sk, hu, ua) one after another, every search once per region. The versions overlap a lot (most offers of the Czech version are Polish and remote offers), so an offer is saved once, from the first region that has it, and `siteRegions` lists all regions it is shown in. All salaries are in the one **Salary currency** you choose (the website converts them), so the regions can be compared. The old **Region of the website** input keeps working for one region.

#### Sorting

The website can't sort: offers come in its own order (promoted and renewed first). **Sort by** therefore reads **the whole search first**, orders the offers (newest first, recently renewed first, highest or lowest monthly salary first; offers without a salary last) and saves the first **Max jobs** of them; job pages are read only for the saved ones. This is exact, not "the newest of the first page", and the pages beyond the saved offers are charged as **Extra page**. Narrow the search with the website filters (a category, a technology) to keep it cheap.

#### Company profile (optional, extra charge)

With **Add description and details** and **Company profile**, every offer gets `companyProfile`, the employer's public profile on the website: name, size, founding year, main and other industries, website, LinkedIn, Facebook, Twitter and Instagram, the about text, video, offices with addresses and GPS, technologies, specializations, benefits and office perks, values, recruitment stages and press links. Each company is read once per run and the **Company profile** event is charged once per company per run, however many of its offers you save. In our sample of 150 offers (2026-11-11), 83 % had a company profile. Business data only: employee quotes with names, job titles and photos are left out, and e-mails and phone numbers are removed from the texts. A profile that can't be read leaves `companyProfile` null and costs nothing.

#### Contacts (optional, personal data)

**What the website shows.** NoFluffJobs handles applications through its own form and does not publish the address applications go to: in our sample of **150 offers (2026-11-11), 0 showed an e-mail or a phone number**, also the 23 offers where the employer chose applying by e-mail. So for reaching an employer use what the website does publish: `applyUrl` (the employer's own recruitment system, about 5 % of the offers), `companyWebsite`, and with **Company profile** the company's LinkedIn and other profiles and its office addresses.

**The option.** If an ad does carry a contact, **Contacts (personal data, extra charge)** with **Add description and details** returns it in its own fields:

| Field | What it has |
|---|---|
| `contactEmails` | E-mail addresses written in the ad, and the application address when the website shows it |
| `contactPhones` | Phone numbers written in the ad, as `+48XXXXXXXXX` |
| `contactNames` | Names of contact persons written right next to an e-mail or phone |

**Why it is an option with a surcharge.** Contacts are extra data most users do not need; keeping them off by default keeps the default output free of personal data; and the surcharge covers the extra processing. Only a saved offer that has at least one contact pays the **Contact details** event, so with the measured share you will usually pay nothing for it.

**Your responsibility.** An e-mail, phone number or name 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. The descriptions keep their contacts replaced with `[e-mail removed]` / `[phone removed]`; employers named like a private person never get contacts; contacts are never written to the log or sent in notifications; people who objected are left out.

#### Market summary (SUMMARY)

Every run writes a free `SUMMARY` record to the key-value store, a small market report of the offers the run found (in monitoring mode also the unchanged ones):

- **Salaries:** the share of offers with a salary, the monthly median and quartiles overall and by salary kind (B2B net + VAT against gross), seniority, category, town and voivodeship (groups of at least 5 offers).
- **Technology demand** (`topTechnologies`): the 30 most asked-for skills (aliases merged) with the number of offers, their share, the median salary of the offers that require them and, with details, how many offers list the skill only as nice to have; `bySalary` ranks the skills by median salary.
- **Salary transparency** (`salaryTransparency`): when employers tell the salary (in the offer, at the first interview…), and the median B2B rate against the median employment salary for each seniority (`b2bOverEmploymentPercent`).
- **Hiring signals** (`hiringSignals`): the 50 companies with the most offers: open offers, offers first published or renewed in the last 7 days, share of fully remote offers, share with a salary, median salary, most asked-for skills, seniority mix and towns. Employers named like a private person are not listed.
- The top 20 companies, work modes, contract types, categories and the website's own number of offers for each search.

Read the whole website (Max jobs 0, no filters) for a report of the whole market.

#### 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 offers and up to **max jobs per message** of them (title, company, town, salary, link; 10 by default), with links to the run and the dataset. The webhook gets the same as JSON (`title`, `summary`, `totalSaved`, `runUrl`, `datasetUrl`, `items`). Descriptions and contacts are never sent, and the URLs and tokens are stored encrypted and never logged. A run that saved nothing sends nothing (turn off **only when something was saved** to get a message every time). A channel that fails is reported in the log and never fails the run.

**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 to e-mail, Microsoft Teams or anything else.

#### Compact output and empty fields

**Compact output** keeps the core fields of every row (id, title, company, towns, country, work mode, salary, contract type, seniority, category, technologies, posting date, link, `applyUrl` and the monitoring fields). **Leave out empty fields** drops fields that are null or an empty list. Both make the rows smaller for AI agents and MCP clients; the price is the same.

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

Fast mode reads up to about 4× faster 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. It matters mostly with **Add description and details**.

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

This actor uses pay-per-event pricing; the current prices are on the **Pricing** tab:

| Event | When |
|---|---|
| Job saved in the dataset | every saved row: one per offer whatever the number of its towns (one per town with **One row per: Town**), also unchanged offers with **Monitoring: include unchanged jobs** |
| Job details | + for an offer saved with **Add description and details**, or given by its job URL (not when the website rejected its job page and the offer was saved from the website's search with its list data) |
| Salary benchmark | + for a saved offer that got a market benchmark (**Salary benchmark**) |
| Market snapshot | + once per region and run with **Salary benchmark: against the whole website** (the regional version read once) |
| Company profile | + once per company per run whose profile was added to a saved offer (**Company profile**) |
| Contact details | + for a saved offer that has at least one contact (**Contacts**); offers without a contact pay nothing |
| Fast mode | + for an offer saved while fast mode was on |
| Notification | once per run that sent its notification (all channels together); a run that sends nothing pays nothing |
| Monitoring page | monitoring mode: every search page read, so unchanged offers cost almost nothing |
| Extra page | pages beyond what the saved offers explain (one search page per 50 saved offers, one job page per offer with details): a search that finds nothing, a filter that reads many pages for few offers, **Sort by** or **Salary benchmark: against this run's searches** with a low Max jobs (the whole search is read), job URLs of ended ads. If the saved offers don't cover a run's cost (e.g. a run that spends long waiting because the website delays requests), the difference is charged as extra pages; the log says how many. A normal run pays nothing here. |

Filtered-out offers, skipped reposts and unchanged offers in monitoring mode (unless you ask for them) are not charged as jobs, and the market summary is free. Offers whose job page could not be read are saved with their list data and not charged the details price. You can set a maximum cost per run; the actor stops when it is reached.

### Input example

```json
{
  "categories": ["backend"],
  "maxItems": 50
}
```

### Output example

```json
{
  "id": "nofluffjobs:FR4BZUN3",
  "source": "nofluffjobs.com",
  "url": "https://nofluffjobs.com/pl/job/change-management-specialist-spyrosoft-wroclaw-1",
  "jobId": "FR4BZUN3",
  "title": "Change Management Specialist",
  "company": "Spyrosoft",
  "companyLogoUrl": "https://static.nofluffjobs.com/companies/logos/jobs_details/spyrosoft_20200313_111958_20220812_123617.png",
  "location": "Wrocław",
  "locations": ["Wrocław", "Brussels", "Spain"],
  "region": "dolnośląskie",
  "country": "PL",
  "countries": ["PL", "BE", "ES"],
  "streetAddress": "plac Nowy Targ 28",
  "postalCode": "50-141",
  "gpsLat": 51.1104135,
  "gpsLon": 17.0385273,
  "workArrangement": "onsite",
  "remote": false,
  "salaryMin": 26208,
  "salaryMax": 29400,
  "salaryCurrency": "PLN",
  "salaryPeriod": "month",
  "salaryMonthlyMin": 26208,
  "salaryMonthlyMax": 29400,
  "salaryHourlyMin": 163.8,
  "salaryHourlyMax": 183.75,
  "salaryKind": "netPlusVat",
  "salaryDisclosure": "visible",
  "salaries": [
    {"contractType": "b2b", "min": 26208, "max": 29400, "currency": "PLN", "period": "month", "kind": "netPlusVat",
     "originalMin": 40, "originalMax": 45, "originalCurrency": "USD", "originalPeriod": "hour", "paidHoliday": false}
  ],
  "contractTypes": ["freelance"],
  "polishContractTypes": ["b2b"],
  "seniority": ["senior"],
  "category": "projectManager",
  "technologies": ["Stakeholder management", "AI"],
  "languagesRequired": ["en"],
  "postedAt": "2026-11-09T16:07:36Z",
  "updatedAt": null,
  "validThrough": "2026-12-09T22:59:59Z",
  "offerUrls": [
    "https://nofluffjobs.com/pl/job/change-management-specialist-spyrosoft-wroclaw-1",
    "https://nofluffjobs.com/pl/job/change-management-specialist-spyrosoft-brussels",
    "https://nofluffjobs.com/pl/job/change-management-specialist-spyrosoft-spain"
  ],
  "detailScraped": true,
  "scrapedAt": "2026-11-10T18:00:00Z"
}
```

(Shortened: the row has more fields, see the dataset schema. `salaries`, `validThrough`, the description and the other texts are filled with **Add description and details**.)

### Limitations

- **About two thirds of the offers show a salary** (measured on all 3 454 offers of the Polish version, 2026-11-10: 65 %). For the rest `salaryDisclosure` says when the employer tells it (at the first interview, at the last one…). Other measured fill rates of the list: company, seniority, category, contract type and posting date 100 %, main technologies 96 %, a town 89 % (the rest are fully remote), GPS 81 %, voivodeship 81 %, street address 29 %, required languages 17 % (all of them with details).
- **The salary is the website's monthly figure.** The website converts hourly, daily and yearly rates and other currencies to a month itself. Without details the range is the one of the offer's first contract type; `salaries` (with details) has every contract type and the original amounts. A few offers have a salary entered with the wrong period (an hourly rate as a monthly salary): it is shown as on the website, but `salaryMonthly*` and `salaryHourly*` stay null.
- **Without details** `contractTypes` has only the offer's first contract type and `technologies` only the main skills of the list.
- **Large searches are checked for completeness.** When a search is read in full (Max jobs 0 or above the number of offers, sorting, the benchmark, monitoring), the actor checks it against the website's own count and adds any offers missed while the list was changing; the log and the status message show both numbers. The extra pages are charged like any other (**Extra page**, or **Monitoring page** in monitoring mode): on a busy day about 1–2 cents on a run of the whole Polish version (about 2 dollars). Runs stopped by Max jobs read nothing more. An offer that ended during the run may still be saved from the moment it was read.
- `region` (voivodeship) is known for the larger Polish towns only; the website gives none for a town.
- `remoteLevel` is the website's own scale (0 = office, 5 = fully remote); the values between are roughly the remote days per week, the exact arrangement is in `hybridDescription`.
- `applyUrl` is filled only when the employer sends candidates to its own recruitment system; otherwise candidates apply on the job page (`url`).
- The website's search has no sorting; **Sort by** reads the whole search to order it (see [Sorting](#sorting)). Without it the offers come in the website's own order (promoted and renewed first).
- `salaryDaily*` and `salaryYearly*` are derived from the monthly figure using standard full-time hours; like the hourly figure they stay null for a salary entered with an obviously wrong period.
- **Salary benchmark:** the offer itself is one of the comparable offers when it is in the market; groups are small for rare categories (see `marketSampleSize`); B2B and gross are compared separately; without details the salary is the one of the offer's first contract type. With the market of this run's searches, offers given by a job URL get no benchmark (use the whole website).
- `renewCount` and `adPackage` are what the website says about the ad's current publication; an ad published again starts from 0.
- `technologiesNormalized` merges common spellings of the same skill (it changed the skills of 10 % of the offers in our run of the whole Polish version); other skills keep the website's spelling.
- `isRepost` compares with the offers of earlier runs with the same Monitoring key: two different openings that look the same can be marked as a repost, and the first run has nothing to compare with.
- Most ads are in English or Polish (`language`, with details). Categories and technologies are in English.
- Free text may still name a contact person: e-mails and phone numbers are removed, names in the text are not. Contacts are rare on this website (0 of 150 sampled offers), so **Contacts** returns empty fields for almost every offer.
- No proxy needed by default. 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. The actor never solves challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/nofluffjobs-scraper").call(run_input={
    "technologies": ["Python"], "seniority": ["senior"], "onlyWithSalary": True, "maxItems": 100,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["salaryMin"], job["salaryMax"], job["salaryKind"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["salary"]["monthly"], summary["salary"]["bySeniority"])
```

### Troubleshooting

- **"no jobs: …"**: the website found nothing; look in the run log how it read the search ("the website read the search as keyword: …") and write technologies and towns as on the website (`Python`, `Warszawa`).
- **"rejecting requests"**: try again later; if it keeps happening, set **Proxy configuration** to Apify Proxy (automatic group; RESIDENTIAL with country Poland if that is rejected too).
- **"Job URLs not found"**: the offer no longer exists; copy the URL of an open job.
- **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.

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

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

### WhatsApp notifications: setup

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

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

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

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

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

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

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

### FAQ

#### Is it legal to scrape NoFluffJobs?

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, never changes IP address to get around a limit and never solves captchas or other challenges. It returns contacts only if you turn on **Contacts (personal data)** (then you are responsible for using them lawfully) and always removes e-mails and phone numbers from the texts. 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, consult a lawyer. This actor is not affiliated with NoFluffJobs.

#### Why is the same offer on the website several times but only once here?

The website shows an offer once for each town, and a remote offer once for each voivodeship. They are the same offer with the same reference, so the actor returns it once, with all the towns in `locations` and all the job pages in `offerUrls`.

#### How are salaries converted?

`salaryMin` and `salaryMax` are the monthly amounts the website shows in the chosen currency (PLN by default); the website converts other periods and currencies itself. Hourly, daily and yearly equivalents use standard full-time hours. B2B rates are net + VAT and employment salaries are gross (`salaryKind`), so they are not directly comparable. With details, `salaries` keeps the original amount, currency and period of every contract type.

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

When the employer's name looks like a private person's name (a sole trader, or a partnership named after its partners), the name is personal data, so `company`, its logo and profile are null and the name is replaced with `[employer]` in the title and texts. On all 347 company names of the Polish version (2026-11-10) it hid one name (a general partnership named after its two partners).

#### Can I get one row per town instead of one per offer?

Yes: set **One row per** to **Town**. The default is one row per offer (you pay once, and `locations` and `offerUrls` have every town and its job page); with a row per town every row is charged.

#### Do I need a proxy?

Not by default: no proxy needed. If the website rejects the requests, use Apify Proxy (see Troubleshooting).

#### Can I get recruiters' e-mails or phone numbers?

Only what an ad itself shows, with **Contacts (personal data, extra charge)**, and that is very little: NoFluffJobs does not publish application e-mails, and none of 150 sampled offers showed an e-mail or a phone (see [Contacts](#contacts-optional-personal-data)). The actor does not look for contacts on other websites. What you do get is `applyUrl`, `companyWebsite` and, with **Company profile**, the company's social profiles and offices.

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

Yes. Apify's own MCP server (mcp.apify.com) exposes every actor in the Store as a tool, so no separate connector is needed; **Compact output** and **Leave out empty fields** keep the rows small for a model's context.

***

Also known as a NoFluffJobs API, No Fluff Jobs scraper, nofluffjobs.com jobs export or Poland IT jobs and salary data (Polish: "oferty pracy IT", "widełki wynagrodzeń", "wynagrodzenia IT", "scraper ofert pracy No Fluff Jobs").

# Changelog

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

# Actor input Schema

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

Words to search for, as typed into the website's search box, e.g. "python", "product owner", "SAP". The website reads known words as a category, technology or town and the rest as keywords (the run log says how it read them). Each line is a separate search, combined with the website filters below. At most 20. Empty = all offers that match the filters.

## `region` (type: `string`):

Which country's version of the website to read: Poland has the most offers (about 3 500); the Czech, Slovak, Hungarian and Ukrainian versions show the offers open to candidates there (about 2 000 for Czechia, many of them the same Polish and remote offers; a few dozen for Ukraine).

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

Read several versions of the website in one run (it replaces "Region of the website"): every search runs once per region. An offer shown in more regions is saved once (from the first region that has it; "siteRegions" lists all of them). All salaries are in the one "Salary currency" you choose, so the regions can be compared.

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

Only offers in these categories. Applied by the website.

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

Search URLs from the website (set the filters on https://nofluffjobs.com/pl and paste the URL, e.g. https://nofluffjobs.com/pl/backend?criteria=seniority%3Dsenior) or job URLs (https://nofluffjobs.com/pl/job/…). A search URL keeps its own filters (the website filters below are not added to it; the actor's filters are). A job URL is always read from its job page, so it is charged with the details.

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

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

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

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

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

Read the job page of every saved offer: description (e-mails and phone numbers removed), daily tasks, requirements, all required and optional skills, benefits, the salary of every contract type in its original currency and period, company size and website, expiry date, how to apply (and the employer's application page), recruitment steps and languages, language levels, methodology, equipment and office perks. Extra charge "Job details" per saved offer (see the Pricing tab). Off = the list data only: salary, contract type, company, towns, work mode, seniority, category and main skills.

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

Format of the description with "Add description and details".

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

Shorten the description to about this many characters (e.g. 300 for a snippet). 0 = full text.

## `salaryBenchmark` (type: `string`):

Compare every saved offer with the market: median and quartiles of the offers with the same salary kind (B2B or gross), category and seniority (in the same town when there are enough), the offer's position (salaryVsMarketPercent, salaryMarketPercentile), an estimated range for offers that show no salary, and the number of the employer's open offers. "This run's searches": the market is every offer your searches find, so they are read whole first (pages beyond the saved offers are charged as "Extra page"). "Whole website": the regional version is read once before the run (2-3 minutes for Poland), charged as "Market snapshot" once per region. Charge "Salary benchmark" per saved offer that got a benchmark (see the Pricing tab).

## `includeCompanyProfile` (type: `boolean`):

With "Add description and details": add the employer's public profile from the website to every offer (companyProfile): founding year, industries, website and social profiles, about text, offices with addresses, technologies, specializations, benefits, values, recruitment stages. Each company is read once per run. Business data only: quotes and names of employees are left out. Charge "Company profile" once per company per run (see the Pricing tab).

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

With "Add description and details": e-mail addresses, phone numbers and names of contact persons the job page shows, in their own fields (contactEmails, contactPhones, contactNames). Very few offers have any (the website hides the application e-mail and employers use its form; see the README for the measured share). These are personal data when they belong to a person: you are responsible for using them lawfully (GDPR). Never returned for employers named like a private person. Charge "Contact details" only for a saved offer that has a contact.

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

Only offers for these levels. Several values = any of them.

## `technologies` (type: `array`):

Only offers that require at least one of these skills, written as on the website, e.g. "Python", "Java", "Spring Boot", "AWS".

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

Only offers in these towns, as the website names them, e.g. "Warszawa", "Kraków", "Wrocław" (diacritics optional). "Remote" = fully remote offers. Several values = any of them.

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

Only offers with one of these contract types.

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

Only offers of these companies, by name as on the website, e.g. "Spyrosoft".

## `jobLanguages` (type: `array`):

Only offers the website marks with one of these languages (the language of the ad and of the work), e.g. English for offers that need no Polish. Several values = any of them.

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

Only offers whose monthly salary reaches at least this amount in "Salary currency" (e.g. 20000). Offers that do not show a salary are left out by the website.

## `salaryCurrency` (type: `string`):

The currency of the salary in the results and of "Salary from" and "Salary up to". The website converts salaries given in another currency itself.

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

Only offers with one of these work modes.

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

Skip offers that show no salary (about a third of the website).

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

Skip offers whose monthly salary starts above this amount (in "Salary currency"). Offers without a salary are kept.

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

Only offers first published in the last N days. 0 = any time.

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

Keep only offers whose title contains at least one of these words (case and diacritics don't matter).

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

Skip offers whose title contains any of these words, e.g. "manager", "sales".

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

Skip offers of companies whose name contains any of these texts.

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

Return only offers that are new or whose title, company, salary, towns, work mode, seniority, contract type or category changed since the previous run with the same Monitoring key. Small daily currency-rate moves are not a change. Unchanged offers are not charged; reading the search costs the small "Monitoring page" fee per search page (see the Pricing tab).

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

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

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

With "Monitoring: only new or changed jobs": also return offers of the previous run that are no longer in the search, as rows with changeType "removed" and removedReason "expired" (the ad ended) or "noLongerMatches" (the ad is live but no longer matches the search). Each is checked on the website (at most 500 per run). Checked only when the run reads every search completely (limits, unread pages or rejected requests skip the check, and the status message says why). Removed rows are charged like any other job.

## `monitoringFields` (type: `array`):

Which fields make an offer "updated". Empty = all of them. E.g. only salaryMin and salaryMax for a feed of salary changes (previousSalaryMin, previousSalaryMax, salaryChangePercent). Changing this list between runs with the same Monitoring key reports every offer as updated once.

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

With "Monitoring: only new or changed jobs": also return the offers that did not change, as rows with changeType "unchanged" (the data of the list; their job pages are not read again). They are saved rows, so each is charged like any other job; without this option unchanged offers are free.

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

With "Monitoring: only new or changed jobs": do not return a new offer when it is an ad published again under a new reference (recognised across your monitoring runs). Skipped offers are not charged. Off = such offers are returned with isRepost true and repostOf (the ID of the earlier offer).

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

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

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

Keep only the core fields of every row: id, title, company, towns, country, work mode, salary, contract type, seniority, category, technologies, posting date, link (and the monitoring fields).

## `rowPer` (type: `string`):

Offer (default): one row per offer with all its towns in "locations". Town: one row for every town of the offer, each with its own address, GPS and job URL; the ID is the offer's ID with the town (nofluffjobs:REF@wroclaw) and jobId stays the same. Every saved row is charged, so an offer in 3 towns costs 3 jobs. Monitoring keeps a separate state for each of the two modes.

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

The website can't sort, so for any other order the actor reads the whole search first, orders the offers and saves the first "Max jobs" of them. With a low "Max jobs" the pages beyond the saved offers are charged as "Extra page". Narrow the search with the website filters to keep it cheap.

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

Drop fields that are null or an empty list from every row (id, source, url, title and scrapedAt always stay).

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

Reads up to about 4x faster 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. It matters mostly with "Add description and details". Small extra charge "Fast mode" per saved offer.

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

No proxy needed by default. If the website rejects the requests, use Apify Proxy (automatic group; RESIDENTIAL with country Poland if that is rejected too).

## `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
{
  "region": "pl",
  "categories": [
    "backend"
  ],
  "maxItems": 50,
  "maxItemsPerSearch": 0,
  "includeDetails": false,
  "descriptionFormat": "text",
  "descriptionMaxLength": 0,
  "salaryBenchmark": "off",
  "includeCompanyProfile": false,
  "includeContacts": false,
  "salaryCurrency": "PLN",
  "onlyWithSalary": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "includeUnchanged": false,
  "skipReposts": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "compact": false,
  "rowPer": "offer",
  "sortBy": "default",
  "excludeEmptyFields": false,
  "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 = {
    "categories": [
        "backend"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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