# theprotocol.it Scraper ($0.84/1K): Polish IT Jobs & Salaries (`tsutseisoftware/theprotocol-it-scraper`) Actor

Scrape theprotocol.it IT jobs: salary in PLN per month and hour (B2B net + VAT and employment gross apart), company, town, voivodeship, technologies, seniority, contracts, work mode. Website filters, details, monitoring of new and removed jobs, alerts, market summary. Unofficial. Praca w branży IT.

- **URL**: https://apify.com/tsutseisoftware/theprotocol-it-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.75 / 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

## theprotocol.it Scraper: Polish IT Jobs & Salaries

Get IT job offers from **theprotocol.it**, the Polish IT job board of the Pracuj.pl group, as clean, ready-to-use data. Search by **keywords**, **technologies** (must have, nice to have, excluded), **seniority**, **IT specialization**, **contract type** (B2B, employment contract, mandate contract…), **work mode** (remote, hybrid, on site), **towns** and **minimum salary**, or paste any theprotocol.it search or job URL. For each offer you get the title, company with logo, all its towns and voivodeships, **work mode**, **salary per month and per hour** with its kind (**B2B net + VAT** and **employment gross** kept apart), the salary of every contract type, seniority, technologies and the publication date.

**$0.84 per 1 000 offers**, $0.94 with the description and details. Proxy included, no extra platform costs.

Built for **watching the Polish 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**. Every run also saves a free **market summary**: salary quartiles by contract kind, seniority and voivodeship, top companies and top technologies.

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

> **Po polsku:** Scraper i API ofert pracy w branży IT z **theprotocol.it** (Grupa Pracuj): pobiera wynagrodzenie miesięcznie i godzinowo, osobno dla B2B (netto + VAT) i umowy o pracę (brutto), firmę, miasta i województwa, tryb pracy (praca zdalna, hybrydowa lub stacjonarna), poziom stanowiska, specjalizację i technologie. Wszystkie filtry serwisu (technologie wymagane, mile widziane i wykluczone, specjalizacja, poziom, rodzaj umowy, miasto, minimalne wynagrodzenie, praca za granicą), opcjonalnie opis i szczegóły oferty, monitoring nowych i usuniętych ofert, powiadomienia w Telegramie, Slacku, Discordzie i WhatsAppie oraz podsumowanie rynku pracy IT. Proxy w cenie. Eksport do Excela, CSV lub JSON.

### Why use this theprotocol.it scraper?

- 💰 **Salaries you can compare.** Every row has the salary per month **and** per hour, its kind (`netPlusVat` for B2B, `gross` for employment) and, as separate columns, the **B2B monthly range** and the **employment monthly range** in PLN, so B2B rates and gross salaries are never mixed. All contract types with their own salary are in `salaries`.
- 🧩 **One offer = one row.** An offer published in 13 towns is one row with all its towns (`cities`, `locations`, `regions`), not 13 rows you pay for.
- 🔎 **All the website's filters** (filtered-out offers cost nothing): technologies (all of them required), nice-to-have and excluded technologies, 22 IT specializations, 10 seniority levels, 8 contract types, work modes, towns, minimum salary, only offers with a salary, work abroad, open to Ukrainians.
- 🧮 **Plus filters the website doesn't have:** salary per hour, salary up to, posted in the last N days, title must (not) contain, company, exclude companies, only "immediate start", only "quick apply", exclude "whole Poland" offers.
- ✅ **Every offer of a large search.** 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 and the status show both numbers.
- 📝 **Description and details (optional):** responsibilities, requirements, nice to have, all required and nice-to-have technologies, benefits, work style, development practices, recruitment stages, specializations, working time, street address, every town of the ad, publication end, the website's AI summary, the employer's reference and the application link.
- 📬 **Monitoring mode:** a daily feed of new and changed offers (`changeType`, `changedFields`), optionally with **removed offers** (`expired` or `noLongerMatches`, with `daysOnline`).
- 📊 **Market summary for free** (SUMMARY record) and **hiring signals** (optional): employer's open positions, days online, hard to fill, reposts under a new ID.
- 🔔 **Job alerts without any integration:** send the saved offers to **Slack, Discord, Telegram, WhatsApp** or your own **webhook** (Zapier, Make, n8n) after each run.
- 🔒 **Privacy first.** No contacts unless you turn them on (**Contacts**, a paid option); e-mails and phone numbers inside texts are always removed, and employers named like a private person are hidden.

#### How it compares with other theprotocol.it scrapers

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

| Capability | This actor | Other scrapers |
|---|---|---|
| Search, technology, seniority, specialization, town, contract type and salary filters, URLs, details | yes | yes |
| Salary per month **and** per hour, B2B and employment in their own columns | yes | one has per month only, one has the salary as text |
| One row per offer with all its towns | yes | yes |
| Nice-to-have and excluded technologies, work abroad, "open to Ukrainians", sorting | yes | partly |
| Every offer of a large search, checked against the website's own count | yes | a single pass |
| Monitoring of new, changed and removed offers, notifications | yes | none |
| Market summary, hiring signals, compact output for AI agents | yes | none |
| Price per 1 000 offers with details | $0.94 | $1.00 and $1.90 |

### What data can you get?

| Field | Example |
|---|---|
| Title, job ID, URL | Administrator Baz Danych PostgreSQL - K/M, 01000000-18c1-… |
| Company, company ID, logo | ASTEK Polska, 20006857 |
| Town, all towns, borough, voivodeship | Warszawa; Kraków, Podgórze; mazowieckie |
| Work arrangement, work modes | hybrid; remote, hybrid, onsite |
| Salary as shown, kind, period | 120–135, netPlusVat, hour |
| Salary per month and per hour | 19 200–21 600 PLN; 120–135 PLN |
| B2B and employment per month | 19 200–21 600 (B2B); 16 000–18 000 (employment) |
| Salary of every contract type | b2b 120–135 net + VAT / hour; employment 16 000 gross / month |
| Contract types (Polish and shared codes) | b2b, employment; freelance, employee |
| Seniority | mid, senior |
| Technologies | PostgreSQL, SQL (nice to have with details: Grafana, Splunk) |
| Labels | new, last call, immediate start, open to Ukrainians, quick apply, whole Poland |
| About the project | Projekt z branży finansowej… |
| Dates | posted, published, valid through |
| With details | description, responsibilities, requirements, benefits, work style, recruitment stages, specializations, working time, street, GPS, AI summary, apply link |

**Fill rates** (measured on 216 offers of 4 searches, 2026-11-13): title, company, town, voivodeship, work mode, seniority, contract type, technologies and date 100 %; a salary at about **40 % of all offers** on the website (25 of 50 on the first page of all jobs, 52 % of Java offers); with details (25 job pages, ours and an independent test): description, responsibilities and requirements 100 %, working time about 95 %, benefits about 75 %, nice-to-have technologies about 50 %, street address about 35 %.

### How to scrape theprotocol.it

1. Open the actor and type a search query (e.g. `python`) or pick technologies, seniority and towns.
2. Set **Max jobs** (20 for a quick test).
3. Turn on **Add description and details** if you need the full ad.
4. Click **Start** and download the data as JSON, CSV or Excel, or get it from the API.

### Use cases

#### Senior Python jobs, remote, B2B, with a salary

```json
{
  "technologies": ["Python"],
  "seniority": ["senior"],
  "workArrangement": ["remote"],
  "contractTypes": ["b2b"],
  "onlyWithSalary": true,
  "maxItems": 100
}
```

#### New Java offers in Kraków or Wrocław every morning, with the removed ones

```json
{
  "technologies": ["Java"],
  "locations": ["Kraków", "Wrocław"],
  "maxItems": 0,
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "java-krakow-wroclaw",
  "slackWebhookUrl": "https://hooks.slack.com/services/..."
}
```

#### DevOps salaries per hour from 150 PLN

```json
{
  "specializations": ["devops"],
  "minSalary": 150,
  "salaryPeriod": "hour",
  "sortBy": "salary",
  "maxItems": 200
}
```

#### A search from the website, with the full ads

```json
{
  "startUrls": [{ "url": "https://theprotocol.it/filtry/python;t/senior;p/zdalna;rw" }],
  "includeDetails": true,
  "maxItems": 50
}
```

#### The whole Polish IT market for a salary report

```json
{
  "maxItems": 0,
  "compactOutput": true
}
```

The SUMMARY record then has the salary quartiles by contract kind, seniority and voivodeship and the 30 most wanted technologies.

#### Website filters

Technologies, nice-to-have and excluded technologies, specializations, seniority, contract type, work mode, towns, minimum salary, only offers with a salary, work abroad and "open to Ukrainians" are applied by the website itself: filtered-out offers cost nothing. Several technologies mean "all of them"; several values of the other filters mean "any of them". Towns can be written in Polish, without diacritics or in English ("Warsaw", "Cracow"). A town or technology the website doesn't know is reported in the status message; when no town of a search is known, nothing is saved (the website would answer offers from the whole country) and the run fails with a hint. **Salary from** compares the top of each offer's salary range per month (or per hour) as in the output.

#### Filters applied by the actor

Salary per hour, salary up to, posted in the last N days, title must (not) contain, company, exclude companies, only "immediate start", only "quick apply" and exclude "whole Poland" offers are checked on the offers read. You don't pay for filtered-out offers; when a filter keeps few of many offers, the pages read beyond the saved offers are charged as **Extra page**.

#### Monitoring mode

With **Monitoring: only new or changed jobs** the actor remembers the offers of the previous run with the same **Monitoring key** and saves only new offers and offers whose title, company, salary, towns, work mode, contract types or seniority changed (`changedFields` lists them). With **Monitoring: include removed jobs** you also get the offers that left the search, checked on their job page: `expired` (the ad ended) or `noLongerMatches` (still online, no longer in the search). Unchanged offers are free; every listing page read in this mode is a **Monitoring page**.

#### Contacts (optional, personal data)

**Contacts** adds the e-mails, phone numbers and names of contact persons written in the ad (`contactEmails`, `contactPhones`, `contactNames`), only with **Add description and details** and never for private employers. These are personal data: you are responsible for using them lawfully (GDPR, e.g. no unsolicited marketing). In our sample 2 of 5 ads had a contact. Descriptions always have their contacts removed.

#### Market summary (SUMMARY)

Every run saves a free SUMMARY record in its key-value store: number of offers, salary median and quartiles overall, by kind (B2B net + VAT against employment gross), by seniority and by voivodeship, top companies, the 30 most wanted technologies, work modes, contract types and seniority levels.

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

Fast mode reads up to about 2.5× 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 theprotocol.it?

Pay per event; the prices are also on the **Pricing** tab.

| Event | Price | When |
|---|---|---|
| Job saved in the dataset | **$0.84 / 1 000** (Bronze $0.81, Silver $0.78, Gold and higher $0.75) | every saved row (one per offer, whatever the number of its towns) |
| Job details | + $0.10 / 1 000 | an offer saved with **Add description and details**, or given by its job URL |
| Actor start | $0.005 per run | once per run |
| Monitoring page | $0.30 / 1 000 pages | monitoring mode: every listing page read (up to 50 offers), so unchanged offers cost almost nothing |
| Extra page | $0.30 / 1 000 pages | pages beyond what the saved offers explain (one page per 50 offers saved from each search, one job page per offer with details): a search that finds nothing, a filter that keeps few offers, job URLs of ended ads. Offers read again because the list changed while it was read are not charged. If the saved offers don't cover a run's cost (e.g. a run that waits long because the website delays requests), the difference is charged as extra pages; the log says how many. A normal run pays nothing here. |
| Hiring signals | + $0.20 / 1 000 | a saved offer that got hiring signals (option) |
| Contact details | + $0.40 / 1 000 | a saved offer with at least one contact (option) |
| Fast mode | + $0.01 / 1 000 | an offer saved while fast mode was on |
| Notification | $0.001 per run | a run that sent its notification (all channels together) |

| Typical run | Price (Free plan) | Typical time |
|---|---|---|
| 20 offers (the example input) | $0.022 | under 10 s |
| 1 000 offers | $0.85 | about 30 s |
| 1 000 offers with details | $0.95 | about 17 minutes (about 7 in fast mode) |
| Daily monitoring of a search with 300 offers, 20 new | $0.024 | under 15 s |
| The whole website (about 4 300 offers) | $3.60 | about 1.5 minutes |

You can set a maximum cost per run; the actor stops when it is reached. Offers whose job page could not be read are saved with their list data and not charged the details price.

### Input example

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

### Output example

```json
{
  "id": "theprotocol:db8d6d77-7bdf-f111-91f2-000d3a48a90c",
  "source": "theprotocol.it",
  "url": "https://theprotocol.it/szczegoly/praca/administrator-baz-danych-postgresql---k-m-warszawa,oferta,01000000-18c1-4436-6436-08df419f5c3c",
  "jobId": "01000000-18c1-4436-6436-08df419f5c3c",
  "title": "Administrator Baz Danych PostgreSQL - K/M",
  "company": "ASTEK Polska",
  "companyId": "20006857",
  "location": "Warszawa",
  "cities": ["Warszawa"],
  "region": "mazowieckie",
  "workArrangement": "hybrid",
  "remote": false,
  "workModes": ["hybrid"],
  "salaryMin": 120,
  "salaryMax": 135,
  "salaryCurrency": "PLN",
  "salaryPeriod": "hour",
  "salaryKind": "netPlusVat",
  "salaryMonthlyMin": 19200,
  "salaryMonthlyMax": 21600,
  "salaryHourlyMin": 120,
  "salaryHourlyMax": 135,
  "salaryB2bMonthlyMin": 19200,
  "salaryB2bMonthlyMax": 21600,
  "salaryEmploymentMonthlyMin": null,
  "salaryEmploymentMonthlyMax": null,
  "salaryText": "120–135 PLN net + VAT / hour (b2b)",
  "salaries": [
    {"contractType": "b2b", "min": 120, "max": 135, "currency": "PLN", "period": "hour", "kind": "netPlusVat",
     "monthlyMin": 19200, "monthlyMax": 21600, "hourlyMin": 120, "hourlyMax": 135}
  ],
  "employmentType": ["fullTime"],
  "contractTypes": ["freelance"],
  "polishContractTypes": ["b2b"],
  "seniority": ["mid"],
  "technologies": ["PostgreSQL", "SQL"],
  "technologiesOptional": ["Grafana", "Splunk", "Zabbix"],
  "specializations": ["it-admin"],
  "language": "pl",
  "postedAt": "2026-11-13T16:01:19Z",
  "validThrough": "2026-12-13T22:59:59Z",
  "isNew": true,
  "isQuickApply": true,
  "projectDescription": "Projekt z branży finansowej, związany z administracją i utrzymaniem baz danych PostgreSQL.",
  "responsibilities": ["Administrowanie i utrzymywanie środowisk PostgreSQL", "…"],
  "benefits": ["dofinansowanie zajęć sportowych", "prywatna opieka medyczna"],
  "detailScraped": true,
  "scrapedAt": "2026-11-13T17:00:00Z"
}
```

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

### Limitations

- **About 40 % of the offers show a salary** (1 694 of 4 277 on 2026-11-13). The row's range is the one of the offer's first contract type; the other contract types are in `salaries` and in the B2B and employment columns. A few offers have a salary entered with an obviously wrong period: it is shown as on the website, but the monthly and hourly figures stay null.
- Hourly and monthly equivalents use standard full-time hours; the salaries are in PLN except for a few offers abroad.
- **Without details** `technologies` has the main technologies of the list, and working time, specializations and the texts of the ad are empty.
- A job given by its URL has all its towns with details; its voivodeship is known for the town of that URL only.
- Towns are matched as the website knows them (e.g. "Warszawa", "Kraków", "Bielsko-Biała"; diacritics are optional, the English names of the big towns work). A town search also returns offers for the whole country, as on the website; **Exclude "whole Poland" offers** leaves them out.
- Offers abroad have their country in `workCountry` (`workCountries` for all workplaces) and `isAbroad`; a workplace given only as a country ("Slovakia") has no town. `country` is always PL, the website's country.
- A run that reads whole searches (Max jobs 0) in the website's own order reads them newest first, so the rows come in that order.
- A job URL whose job page the website rejects is looked up in the website's search (the same job ID) and saved with its listing data (no description and other job-page fields, no job-details charge); a job ID alone cannot be looked up that way.
- Free text may still name a contact person: e-mails and phone numbers are removed, names in the text are not.
- The proxy is set by default and included in the price. 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/theprotocol-it-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["salaryMonthlyMin"], job["salaryMonthlyMax"], job["salaryKind"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["salary"]["byKind"], summary["topTechnologies"][:10])
```

**Compact output** keeps the core fields (title, company, town, salary, work mode, seniority, contract types, technologies, date, link) plus the fields of the options you turned on: smaller rows for AI agents, MCP clients and spreadsheets.

### Troubleshooting

- **"Not known to theprotocol.it …"**: a town or technology the website doesn't know; write it as on the website (`Warszawa`, `Python`, `Node.js`, `C#`).
- **"Your maximum cost per run … does not cover the start of the run"**: raise the maximum cost per run in the run options.
- **"job URLs or IDs of ended or unknown ads, nothing was saved"**: the ads are no longer published; use the URL of an open job.
- **"no jobs: …"**: the website found nothing for the search; try fewer filters.
- **"rejecting requests"**: set **Proxy configuration** back to the default and try again later.
- **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
- [NoFluffJobs Scraper](https://apify.com/tsutseisoftware/nofluffjobs-scraper): Polish IT jobs: salary per month and hour, B2B or employment, technologies, salary benchmark, monitoring
- [JustJoin.it Scraper](https://apify.com/tsutseisoftware/justjoin-it-scraper): Polish IT jobs: salary per contract type, technologies with level, seniority, remote, radius from a city, alerts
- [RocketJobs.pl Scraper](https://apify.com/tsutseisoftware/rocketjobs-pl-scraper): Polish non-IT jobs (sales, marketing, logistics and more): salary per contract type, subcategories, radius from a city, alerts
- [Praca.pl Scraper](https://apify.com/tsutseisoftware/praca-pl-scraper): jobs from one of the oldest Polish job boards: salary, contract type, work mode, relocation offers, monitoring
- [OLX Praca Scraper](https://apify.com/tsutseisoftware/olx-praca-scraper): Polish job ads from OLX: salary as written, place, company or private advertiser, optional job data and phone numbers of companies
- [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 theprotocol.it?

It reads only publicly available data, without logging in, at most 60 requests per minute (150 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 theprotocol.it or Grupa Pracuj.

#### How are B2B and employment salaries kept apart?

`salaryKind` says what the row's range is (`netPlusVat` = B2B net + VAT, `gross` = employment contract gross). `salaryB2bMonthlyMin`/`Max` and `salaryEmploymentMonthlyMin`/`Max` always hold the B2B and the employment salary per month in PLN, whatever the ad lists first, so you can sort and compare each kind directly.

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

The employer is a sole trader whose company name is a private person's name. For privacy the name, logo and address are left out and the name is removed from the texts of the ad (2 of 216 offers in our sample, both sole traders).

#### Do I need a proxy?

No setup needed: the proxy is set by default and included in the price.

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

Yes. Use **Compact output** for smaller rows, and call the actor through the Apify API or Apify's MCP server.

Also known as a theprotocol.it API or theprotocol.it job scraper (Polish: "praca w branży IT", "oferty pracy IT theprotocol", "scraper ofert pracy IT").

# Changelog

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

# Actor input Schema

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

Keywords to search for, e.g. "python", "devops", "data engineer", "SAP". Each query is a separate search (combined with the technologies, towns and other filters below). At most 20.

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

Only jobs that require all of these technologies, as the website names them, e.g. "Python", "Java", "React", "Node.js", "C#", "AWS". A technology the website doesn't know is reported in the status.

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

Only jobs in at least one of these towns, e.g. "Warszawa", "Kraków", "Wrocław", "Gdańsk" (diacritics are optional: "lodz" works, and English names such as "Warsaw" or "Cracow" are understood). Fully remote jobs open to the whole country are included, as on the website. A town the website doesn't know is reported; when no town of the search is known, nothing is saved and the run says so.

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

Only jobs for at least one of these position levels.

## `specializations` (type: `array`):

Only jobs in at least one of these IT specializations (the website's categories).

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

Only jobs offering at least one of these contract types.

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

Only jobs offering at least one of these work modes.

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

Search URLs from theprotocol.it, e.g. https://theprotocol.it/filtry/python;t/senior;p/zdalna;rw or https://theprotocol.it/praca?kw=devops (set the search and filters on the website and paste the URL), or job URLs (https://theprotocol.it/szczegoly/praca/…,oferta,<id>). The filters of this form are added to search URLs too, unless the URL already sets them.

## `jobIds` (type: `array`):

theprotocol.it job IDs (the ID at the end of a job URL, e.g. 01000000-18c1-4436-6436-08df419f5c3c) to read one by one with all details. At most 2000.

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

Maximum number of jobs saved. You pay per saved job. 0 = no limit.

## `maxItemsPerStartUrl` (type: `integer`):

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

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

Open each job page to add the description (e-mails and phone numbers removed), responsibilities, requirements, nice-to-have technologies, benefits, work style, recruitment stages, specializations, working time, street address, every town of the ad, the publication period, the website's AI summary and the apply links. Extra charge "Job details": $0.10 per 1 000 jobs whose page was read.

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

With "Add description and details": shorten the description to about this many characters (e.g. 300 for a snippet). 0 = full text.

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

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

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

Only jobs whose salary reaches at least this amount in PLN per "Salary period", e.g. 20000 per month or 120 per hour: the top of the range of the row's salary (salaryMonthlyMax or salaryHourlyMax, hourly and monthly converted at standard full-time hours). Jobs without a salary are skipped.

## `salaryPeriod` (type: `string`):

The period of "Salary from" and "Salary up to".

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

Skip jobs that show no salary (about 40 % of theprotocol.it jobs show one).

## `technologiesNiceToHave` (type: `array`):

Only jobs that list these technologies as nice to have.

## `excludeTechnologies` (type: `array`):

Skip jobs that require any of these technologies, e.g. "PHP".

## `abroad` (type: `array`):

Only jobs with a workplace outside Poland, in the EU or in the rest of the world.

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

Only jobs the employer marked as open to candidates from Ukraine.

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

Skip jobs whose salary starts above this amount (per "Salary period"), e.g. to find junior jobs. Jobs without a salary are kept.

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

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

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

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

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

Skip jobs whose title contains any of these words, e.g. "senior", "lead".

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

Keep only jobs of companies whose name contains one of these texts.

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

Skip jobs of companies whose name contains any of these texts (e.g. recruitment agencies).

## `onlyImmediateStart` (type: `boolean`):

Only jobs labelled "praca od zaraz" (start right away).

## `onlyQuickApply` (type: `boolean`):

Only jobs with the website's quick application.

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

Skip offers published for the whole country (mostly remote jobs), so that a search for a town returns jobs in that town.

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

Return only jobs that are new or whose title, company, salary, towns, work mode, contract types or seniority changed since the previous run with the same Monitoring key. Unchanged jobs are free; every listing page read in this mode is the "Monitoring page" event ($0.30 per 1 000 listing pages; one page = up to 50 jobs).

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

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

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

With "Monitoring: only new or changed jobs": also return jobs 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), checked on the job page. 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.

## `includeHiringSignals` (type: `boolean`):

Adds to every job how many open positions its employer has (companyOpenPositions), days online (daysOnline) and hardToFill; with monitoring also reposts of the same position under a new job ID (isRepost, repostOf, repostCount). At no extra run time; $0.20 per 1 000 jobs that got the signals (the "Hiring signals" event).

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

Adds the contacts the job page shows: the e-mails, phone numbers and names of contact persons written in the ad (contactEmails, contactPhones, contactNames). Needs "Add description and details". Never for private employers. These are personal data: you are responsible for using them lawfully (GDPR, e.g. no unsolicited marketing). Descriptions keep their contacts removed. $0.40 per 1 000 jobs that got at least one contact (the "Contact details" event).

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

Only the core fields (title, company, place, salary, work mode, seniority, contract types, technologies, date, URL) plus the fields of the options you turned on. Smaller rows for AI agents, MCP clients and spreadsheets.

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

Token of your Telegram bot (from @BotFather), e.g. 123456789:AA... Used with "Telegram chat ID".

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Reads up to about 2.5 times faster, which helps most with "Add description and details". It drops back to the normal speed for the rest of the run at the first sign of load, and it never changes IP address to get around a limit. Extra charge "Fast mode": $0.01 per 1 000 jobs saved while the fast speed was on.

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

Order of the website's search results (matters with Max jobs). theprotocol.it URLs keep their own order unless you choose another one here. A run that reads whole searches (Max jobs 0, no other limit) with the website's order reads them newest first, so that no offer is missed while the list changes.

## `maxPages` (type: `integer`):

Safety limit for each search or URL (50 jobs per page). 0 = no limit.

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

Apify Proxy (automatic datacenter proxy) by default, included in the price. Keep the default unless the run says the website rejects requests.

## `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": [
    "python"
  ],
  "maxItems": 20,
  "maxItemsPerStartUrl": 0,
  "includeDetails": false,
  "descriptionMaxLength": 0,
  "descriptionFormat": "text",
  "salaryPeriod": "month",
  "onlyWithSalary": false,
  "openToUkrainians": false,
  "onlyImmediateStart": false,
  "onlyQuickApply": false,
  "excludeWholePoland": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "includeHiringSignals": false,
  "includeContacts": false,
  "compactOutput": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "fastMode": false,
  "sortBy": "relevance",
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "sendErrorReports": true
}
```

# Actor output Schema

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

The saved job offers (one row per offer with all its towns), in the run's default dataset.

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

Free summary of the offers the run found: salary quartiles in PLN by contract kind, seniority and voivodeship, top companies and technologies, work modes and contract types.

# 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": [
        "python"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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