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

Scrape JustJoin.it job offers: salary per contract (B2B, employment, mandate) in PLN per month and hour, company, towns, voivodeship, work mode, seniority, skills and category. Website filters, optional job pages, monitoring of new and removed jobs, IT market summary. Unofficial. Oferty pracy IT.

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

## Pricing

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

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

Get job offers from **JustJoin.it**, the biggest Polish IT job board, as clean structured data. Search by **keywords**, **categories** (Python, Java, DevOps, Data, AI/ML, …), **towns**, **seniority**, **work mode** (remote, hybrid, office), **contract type** (B2B, employment contract, mandate) and salary, or paste a listing URL from the website. Every job comes with the **salary of each contract type** as the employer gave it, with monthly and hourly equivalents, the required skills, all towns of the offer with the voivodeship and GPS, and the dates.

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

**How big is the website?** About **11 000 active offers** (November 2026) in 24 categories; about 42 % of them show a salary. 1 000 jobs take under a minute and cost **$0.56**; the whole website costs about $6.

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

> **Po polsku:** Scraper i API ofert pracy IT z **JustJoin.it**: pobiera wynagrodzenie (widełki) dla każdego rodzaju umowy (B2B, umowa o pracę, umowa zlecenie) w PLN miesięcznie i godzinowo, firmę, miasta z województwem i GPS, tryb pracy (praca zdalna, hybrydowa lub stacjonarna), poziom doświadczenia, kategorię i wymagane technologie. Filtry serwisu (kategoria, np. Python, Java lub DevOps, miasto z promieniem, poziom, tryb pracy, rodzaj umowy, minimalne wynagrodzenie), monitoring nowych i usuniętych ofert, powiadomienia w Telegramie, Slacku, Discordzie i WhatsAppie oraz podsumowanie rynku pracy IT. Eksport do Excela, CSV lub JSON.

### Why use this JustJoin.it scraper?

- 💰 **Salaries you can compare.** JustJoin.it offers often have a different pay for B2B and for an employment contract. You get both: `salaries` has every contract type with its range, currency, period (hour, day, month, year) and kind (`gross`, `net`, `netPlusVat`), and `salaryMin`/`salaryMax` with **monthly and hourly equivalents** (standard full-time hours) for the main one. A gross employment salary and a net + VAT B2B rate are never mixed into one range, and the website's own currency conversions are left out.
- 🧑‍💻 **Tech stack and seniority for every job**, at no extra cost: required and nice-to-have skills, category, seniority, working time; with job pages also the **level of every skill** (1–5) and the required languages with level.
- 📍 **Places done right.** One row per offer with all its towns (`locations`), the voivodeship of each (`regions`, also for "Warsaw", "Krakow" or "Warszawa (Mazowieckie)"), GPS, and the URL of the offer in each town.
- 🔎 **The website's own filters** (filtered-out jobs cost nothing): category, town or fully remote, seniority, work mode, contract type, working time, language, minimum salary, only with salary, published in the last days, sorting. The actor checks that the website really applied them and never returns unfiltered results.
- 📏 **Radius search:** jobs within N km of a town (the website's own filter) or of any coordinates, with the distance in every row.
- 🧮 **Plus filters the website doesn't have:** skills, company, excluded companies, an exact "posted in the last N days".
- 📬 **Monitoring mode:** a daily feed of new and changed jobs (`changeType`), optionally with **removed** and reappeared jobs and `daysOnline`.
- 🔔 **Job alerts:** send the saved jobs to Slack, Discord, Telegram, WhatsApp or your own webhook after each run; with monitoring only the changes.
- ⚡ **Fast and cheap:** 1 000 jobs in under a minute with 256 MB of memory; job pages only if you ask for them. Searches bigger than the website's own limit are read in full automatically, so "all jobs" really means all.
- 🔒 **Privacy first.** No contact persons, e-mails or phone numbers; e-mails and phone numbers inside descriptions are replaced with `[e-mail removed]` / `[phone removed]`. An employer whose name looks like a private person's name is hidden.

### What data can you get?

| Field | Example |
|---|---|
| Title, job ID, slug, URL | Senior Software Engineer (Python, Java, RAG), `f6c85d1b-…`, https://justjoin.it/job-offer/… |
| Company, logo | j-labs |
| Location, all towns, voivodeship, country, street, GPS | Kraków; \["Kraków", "Warszawa"]; małopolskie; PL; Zabłocie 43A; 50.049, 19.966 |
| Work mode | workArrangement `hybrid`, remote `false`, workModes `["hybrid"]` |
| Salary | 160 – 190 PLN per hour, `netPlusVat`, B2B (monthly 25 600 – 30 400) |
| Salaries per contract | `[{"contractType": "b2b", "min": 160, "max": 190, "currency": "PLN", "period": "hour", "kind": "netPlusVat", "monthlyMin": 25600, "monthlyMax": 30400}]` |
| Contract, working time, seniority | polishContractTypes `b2b`, `employment`, `mandate`, `specificTask`, `internship`; employmentType `fullTime`; seniority `senior` |
| Category and skills | Python; technologies `["Python", "Java", "RAG"]`; technologiesOptional |
| Dates and labels | postedAt, lastPublishedAt, validThrough, isPromoted, isSuperOffer, openToUkrainians, remoteInterview, applyMethod |
| With **Add description and details** | description (text, Markdown or HTML; with **Description formats** also descriptionText, descriptionMarkdown and descriptionHtml at once), skillLevels, languagesRequired, companySize, companyUrl, applyUrl, country code |
| With **Coordinates** | distanceKm (straight line from your point to the nearest town of the offer) |
| With **Monitoring** | changeType, firstSeenAt, changedFields; removed jobs with removedAt, lastSeenAt, daysOnline; reappeared; isRepost and repostOf for an ad published again under a new ID; unchanged jobs on request |

See the **Output** tab for all fields. The dataset has views for **Overview**, **Salaries**, **Tech stack**, **Places**, **Details**, **Monitoring** and **Removed jobs**.

How often the fields are filled (905 jobs, November 2026): title, company, location, GPS, work mode, seniority, category, skills and dates 100 %; voivodeship 90 % (the rest are workplaces abroad); salary 42 % (the rest say "Undisclosed Salary"); contract type 63 %; street 82 %; several towns 18 %.

### How to scrape JustJoin.it

1. Pick **Categories** and/or enter **Search queries** (e.g. `django`, `data engineer`) and **Locations** (e.g. `Warszawa`, `Kraków`, `remote`), or paste a listing URL from the website into **JustJoin.it URLs**, e.g. `https://justjoin.it/job-offers/warszawa/java?experience-levels=senior`.
2. Optionally set the seniority, work mode, contract type, salary and other filters, and turn on **Add description and details** if you need the full text.
3. Set **Max jobs** (0 = everything) and click **Start**. Download the results as JSON, CSV or Excel, or connect them to Google Sheets, Slack or Make.

### Use cases

#### Senior Python B2B rates in Warsaw

```json
{
  "categories": ["python"],
  "locations": ["Warszawa"],
  "seniority": ["senior"],
  "contractTypes": ["b2b"],
  "onlyWithSalary": true,
  "maxItems": 200
}
```

#### New remote DevOps jobs every morning

Schedule a daily run; each run returns only new or changed jobs and the ones that disappeared.

```json
{
  "categories": ["devops"],
  "workModes": ["remote"],
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "remote-devops",
  "maxItems": 0
}
```

#### Jobs that ask for Kubernetes, with full descriptions

```json
{
  "searchQueries": ["kubernetes"],
  "technologies": ["Kubernetes"],
  "includeDetails": true,
  "descriptionFormat": "markdown",
  "maxItems": 100
}
```

#### A search set up on the website

```json
{
  "startUrls": [{ "url": "https://justjoin.it/job-offers/krakow/data?experience-levels=mid,senior&with-salary=yes" }],
  "maxItems": 0
}
```

#### The whole website, for a market snapshot

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

#### Website filters (applied by JustJoin.it)

Category, town with a **Radius (km)** around it, seniority, work mode, contract type, working time, languages, **Only jobs with a salary**, **Salary from** (the website's minimum salary, a monthly amount in PLN; hourly rates and other currencies are converted by the website), **Posted in the last N days** (1, 7, 14 or 30 days on the website; other values are checked by the actor) and **Sort by**. The website applies them itself, exactly like its search form, so filtered-out jobs cost nothing. The actor checks that every filter was applied; if one was not, the search is skipped and the status message says so.

#### Search around a town or a point

- **Locations + Radius (km)**: the website's own radius around a town, e.g. `"locations": ["Gliwice"], "radiusKm": 50`. It costs nothing extra. Without a radius the website uses 30 km; `0` is the town itself. The website matches every town of an offer, so an offer shown under Warszawa can be in the result because it is also open in Katowice (see `locations`).
- **Coordinates + Radius (km)**: any point, e.g. `"nearCoordinates": "50.2945, 18.6714", "radiusKm": 25`. The website cannot search around a point, so the actor looks through the search you gave (all jobs when you gave none) and keeps the offers that have a town within the radius, in a straight line; each row gets `distanceKm`. The jobs it drops are free, the listing pages looked through beyond the saved jobs are charged as **Extra page**: all of Poland costs about $0.05, a single category much less. Add a category or keywords to make it cheaper.

#### Salary filters

**Salary from** in PLN is the website's own filter: a monthly amount, hourly rates and other currencies are converted by the website, jobs without a salary are left out, nothing extra is read. **Salary up to** and a **Salary currency** other than PLN are compared by the actor, because the website has no such filter: it takes the salaries the employer gave in that currency, as a monthly equivalent (standard full-time hours), and never converts between currencies. **Salary up to** drops jobs whose salary starts above the amount and jobs paid only in another currency, and keeps jobs without a salary; add **Only jobs with a salary** to drop those. Listing pages read beyond the saved jobs are charged as **Extra page**.

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

**Skills** (the exact skill name, required or nice to have), **Company** and **Exclude companies**. The website cannot filter by them, so the actor reads the search and keeps the jobs that match: the jobs it drops are free, the listing pages read beyond the saved jobs are charged as **Extra page** ($0.20 per 1 000 pages).

#### Monitoring mode explained

With **Monitoring: only new or changed jobs** the actor remembers the jobs of the previous run with the same **Monitoring key** and saves only jobs that are new (`changeType: new`) or whose title, company, salary, towns, work arrangement or seniority changed (`updated`, with `changedFields`). The publication date is not a change: employers refresh offers all the time. With **Monitoring: include removed jobs** you also get jobs that are no longer in the search (`removed`, with `lastSeenAt`, `removedAt` and `daysOnline`) and jobs that came back (`reappeared`). Removed jobs are checked only when the run read every search completely. With **Add description and details**, job pages are opened only for the new and changed jobs.

- **Monitoring: include unchanged jobs** also returns the jobs that did not change (`changeType: unchanged`, listing data, no job page read again). They are saved rows, so they are charged like any other job.
- **Monitoring: skip reposted jobs**: employers publish the same ad again under a new ID. A new job that is the same job seen in an earlier run under another ID is marked `isRepost: true` with `repostOf` (the earlier ID); with this option it is not returned and not charged. Reposts are recognized from the first monitoring run with this version on.

#### Notifications (job alerts)

Fill in a Slack or Discord webhook, 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 (Zapier, Make, n8n, your server), and after each run the actor sends the saved jobs there: title, company, town, salary and link, at most **Max jobs per message** of them (default 10) and "…and N more", with links to the run and the dataset. With monitoring that is a daily alert with the new, changed and removed jobs; nothing is sent on a day without changes (unless you turn **Only when something was saved** off). Descriptions and contacts are never sent, the webhook addresses and tokens are stored encrypted, and a channel that fails never fails the run. A run that delivered its notification is charged once as **Notification**, whatever the number of channels.

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

#### Description in several formats

**Description format** picks the format of `description` (plain text, Markdown or clean HTML). **Description formats (several at once)** adds `descriptionText`, `descriptionMarkdown` and `descriptionHtml` next to it, whichever you pick, from the same job page and for the same price. E-mails and phone numbers are removed in every format, and so is the name of an employer who is a private person.

#### Compact output for AI agents

**Compact output** keeps the core fields of every row (id, title, company, towns, voivodeship, country, work mode, salary with the monthly equivalent, contract type, seniority, category, skills, posting date, link 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.

#### Market summary (SUMMARY)

Every run saves a free JSON record `SUMMARY` in the key-value store: how many jobs matched, the share with a salary, the **median and quartiles of the monthly salary in PLN** overall and by salary kind (gross vs. net + VAT), seniority, category and voivodeship, the top 20 companies, the top 30 technologies, and the split by work arrangement, contract type, seniority, category and region. In monitoring mode it covers unchanged jobs too.

### How much does it cost to scrape JustJoin.it?

This actor uses pay-per-event pricing (see the **Pricing** tab for the current prices):

| Event | Price per 1 000 | Bronze | Silver | Gold and higher |
|---|---|---|---|---|
| Job saved in the dataset | **$0.56** | $0.55 | $0.54 | $0.53 |
| Job page read ("Add description and details", job URLs) | + $0.15 | + $0.15 | + $0.15 | + $0.15 |
| Fast mode | + $0.01 | + $0.01 | + $0.01 | + $0.01 |
| Monitoring: listing page checked (per 1 000 pages = 50 000 jobs) | $0.20 | $0.20 | $0.20 | $0.20 |
| Extra page (per 1 000 pages read beyond the saved jobs) | $0.20 | $0.20 | $0.20 | $0.20 |
| Notification (per run that sent one) | $0.001 | $0.001 | $0.001 | $0.001 |
| Actor start (per run) | $0.002 | $0.002 | $0.002 | $0.002 |

1 000 jobs from the listing cost **$0.56**, with descriptions **$0.71**. The whole website (about 11 000 jobs) costs about $6. A daily monitoring run of a search with 500 jobs that finds 10 new ones costs about $0.01. Filtered-out jobs, unchanged jobs in monitoring mode and the market summary are free.

**Extra page** ($0.0002 a page) is charged at the end of the run for pages the saved jobs do not explain. A plain search has none. It applies to a search without jobs, a town or job URL that is not on the website (one page each), a **Skills**, **Company**, **Salary up to** or **Coordinates** filter that reads many listing pages for a few jobs (the website cannot filter by them), and a page that had to be read twice. Pages paid as monitoring pages and pages the website rejected are never extra pages. Your maximum cost per run covers them too.

### Input example

```json
{
  "categories": ["python"],
  "seniority": ["mid", "senior"],
  "workModes": ["remote"],
  "maxItems": 100
}
```

### Output example

```json
{
  "id": "justjoin:f6c85d1b-2af2-4f96-a944-7990aa6a0508",
  "source": "justjoin.it",
  "url": "https://justjoin.it/job-offer/j-labs-senior-software-engineer-python-java-knowledge-graph-al-rag--krakow-python",
  "jobId": "f6c85d1b-2af2-4f96-a944-7990aa6a0508",
  "slug": "j-labs-senior-software-engineer-python-java-knowledge-graph-al-rag--krakow-python",
  "title": "Senior Software Engineer (Python, Java, Knowledge Graph, Al, RAG)",
  "company": "j-labs",
  "location": "Kraków",
  "locations": ["Kraków"],
  "region": "małopolskie",
  "regions": ["małopolskie"],
  "country": "PL",
  "streetAddress": "Zabłocie 43A",
  "gpsLat": 50.0492153,
  "gpsLon": 19.9659287,
  "workArrangement": "hybrid",
  "remote": false,
  "workModes": ["hybrid"],
  "salaryMin": 160,
  "salaryMax": 190,
  "salaryCurrency": "PLN",
  "salaryPeriod": "hour",
  "salaryMonthlyMin": 25600,
  "salaryMonthlyMax": 30400,
  "salaryHourlyMin": 160,
  "salaryHourlyMax": 190,
  "salaryKind": "netPlusVat",
  "salaryContractType": "b2b",
  "salaries": [
    { "contractType": "b2b", "min": 160, "max": 190, "currency": "PLN", "period": "hour", "kind": "netPlusVat", "monthlyMin": 25600, "monthlyMax": 30400 }
  ],
  "employmentType": ["fullTime"],
  "contractTypes": ["freelance"],
  "polishContractTypes": ["b2b"],
  "seniority": ["senior"],
  "mainCategory": "Python",
  "categories": ["Python"],
  "technologies": ["Python", "Java", "Knowledge Graph", "AL", "RAG"],
  "technologiesOptional": [],
  "postedAt": "2026-11-10T17:55:01Z",
  "lastPublishedAt": "2026-11-05T17:53:11Z",
  "validThrough": "2026-11-15T22:59:59Z",
  "isSuperOffer": true,
  "applyMethod": "external",
  "detailScraped": false,
  "sourceUrl": "https://justjoin.it/job-offers/all-locations/python",
  "scrapedAt": "2026-11-10T18:16:33Z"
}
```

### Good to know

- **Salary.** Amounts are exactly what the employer entered. A few employers enter an hourly rate as a monthly salary (e.g. 150–200 PLN "per month"): such amounts stay as they are in `salaryMin`/`salaryMax`, but get no monthly or hourly equivalent. A single amount is both bounds. Salaries in EUR, USD, GBP or CHF are not converted to PLN and are left out of the PLN summary.
- **The website's count is bigger than the number of jobs.** JustJoin.it counts an offer once for every town ("973 offers" for 525 listed offers); the actor returns each offer once, with all its towns.
- **Category** comes from the offer's address on the website; an offer published in two categories is two offers on the website, too.
- **Publication date.** `postedAt` is the date the website orders by; employers refresh offers, so an older offer can have a recent date (`lastPublishedAt` then differs).
- **Voivodeship** is matched from the town name, at no extra cost; it is null abroad and for places that are not a town.
- Searches bigger than the website's own limit are read in full automatically (when Max jobs and Max pages don't limit the run); the status message says if anything was left out.
- The order of the website's results can move while the run reads them; the actor watches for that so that no offer is missed.
- Free text may still name a contact person (e.g. "write to Anna"): e-mails and phone numbers are removed, names in the text are not.
- **Job URLs when the job page is rejected.** The job is looked up in the website's search and saved with its listing data (no description and other job-page fields, no job-page charge); when the search does not show it, the status says the job URL could not be read (try again later).
- No proxy needed. 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. It never solves captchas or other challenges.

### For AI agents and API users

Apify's own MCP server (mcp.apify.com) exposes every actor in the Store as a tool, so an AI agent can call this actor without a separate connector; **Compact output** and **Leave out empty fields** keep the rows small for a model's context.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/justjoin-it-scraper").call(run_input={
    "categories": ["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["salaryKind"], job["technologies"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["salary"]["byKind"])
```

### Troubleshooting

- **"Not found on JustJoin.it"**: the town is not one the website knows. Write it as on the website (`Warszawa`, `Kraków`, `Wrocław`, `Gdańsk`, `Poznań`, `Łódź`, `Katowice`…) or use `remote`.
- **"the website did not apply the filters"**: a URL you pasted has a filter value the website does not know; open it in your browser and copy the address again.
- **"rejecting requests"**: try again later, or set **Proxy** to Apify Proxy.
- **Fewer jobs than the website's count**: the website counts an offer once per town; see "Good to know".

### 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
- [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 JustJoin.it?

It reads only publicly available data, without logging in, at most 30 requests per minute (120 in the 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 no contact persons, removes e-mails and phone numbers from descriptions and hides employer names that look like a private person's name. The website's terms of use may restrict automated access; you are responsible for how you use the data, especially for anything covered by GDPR or database rights. This actor is not affiliated with or endorsed by Just Join IT.

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

When the employer's name looks like a private person's name (a sole trader advertising under their own name), the name is personal data, so `company`, the logo, website, street, GPS and application link are null and the name is replaced with `[employer]` in the title and description. This is automatic; in doubt, privacy wins. In our sample of 248 names (November 2026), no company was hidden by mistake. The offer's URL is the website's own address and can still contain the name.

#### How are salaries converted?

Hourly, daily and yearly equivalents use standard full-time hours; obviously mislabelled periods get no equivalent. Nothing is converted between currencies or between gross and net.

#### Do I need a proxy?

No proxy needed.

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

No. The actor deliberately returns no contact persons, e-mails or phone numbers.

***

Also known as a JustJoin.it API, Just Join IT scraper or justjoin jobs scraper (Polish: "oferty pracy IT", "praca IT zdalna", "widełki płacowe IT", "scraper ofert pracy JustJoin.it").

# Changelog

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

# Actor input Schema

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

Keywords the website searches in job titles, companies and skills, e.g. "django", "data engineer", "SAP". Each query is a separate search (combined with the locations, categories and website filters).

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

JustJoin.it categories, one search each. Empty = all categories.

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

Towns as on the website, one search each, e.g. "Warszawa", "Kraków", "Wrocław", "Gdańsk" (diacritics are optional, "Warsaw" works), or "remote" for fully remote jobs. Empty = all locations. A town the website doesn't know is reported, not replaced by the whole country.

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

Distance around each town of "Locations" (the website's own radius filter, so it costs nothing extra) or around "Coordinates". Empty = 30 km, which is what the website uses; 0 = the town itself.

## `nearCoordinates` (type: `string`):

A point as "latitude, longitude", e.g. "50.2945, 18.6714": keep only jobs with a town within "Radius (km)" of it (straight-line distance to the nearest town of the offer; the row gets distanceKm). The website cannot search around a point, so the actor reads the search and filters it itself: the listing pages read beyond the saved jobs are charged as "Extra page". Narrow the search with a category or keywords, or use "Locations" with a radius instead where a town fits.

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

Listing URLs from JustJoin.it, e.g. https://justjoin.it/job-offers/warszawa/java?experience-levels=senior (set the search and filters on the website and paste the URL), or job URLs (https://justjoin.it/job-offer/<slug>; a job URL is read with all details and charged as a job with "Job page read"). Website filters below are added to listing URLs too, unless the URL already sets them.

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

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

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

Read at most this many listing pages (50 jobs each) of every search. 0 = no limit. Searches bigger than the website's own limit are read in full automatically when neither limit is set.

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

Open each job page to add the description (e-mails and phone numbers removed), skill levels, required languages, company size and website and the application link. Extra charge "Job page read" (see the Pricing tab) per job whose page was read. Off: listing data only (salary, skills, places, seniority, work mode).

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

With "Add description and details": the format of the description.

## `descriptionFormats` (type: `array`):

With "Add description and details": also return the description in each of these formats, as the fields descriptionText, descriptionMarkdown and descriptionHtml (next to "description"). E-mails and phone numbers are removed in every format. No extra charge.

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

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

Only jobs of these experience levels.

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

Only jobs with one of these work modes.

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

Only jobs offering one of these contract types.

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

Only jobs with one of these working times.

## `languages` (type: `array`):

Only jobs that ask for one of these languages (the website's language filter).

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

Skip jobs with an undisclosed salary.

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

Only jobs whose monthly salary reaches at least this amount (e.g. 20000); jobs without a salary are left out. In PLN it is the website's own "minimum salary" filter (the website converts hourly rates and other currencies itself). With another "Salary currency" the actor compares the salaries the employer gave in that currency (monthly equivalent).

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

Skip jobs whose monthly salary in "Salary currency" starts above this amount (e.g. 25000). The website has no such filter, so the actor compares the monthly equivalent of the salaries the employer gave in that currency (nothing is converted between currencies, so jobs paid only in another currency are left out); jobs without a salary are kept (add "Only jobs with a salary" to drop them). Listing pages read beyond the saved jobs are charged as "Extra page".

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

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

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

Only jobs published or refreshed in the last N days. The website filters by 1, 7, 14 or 30 days; for other values it gives the next longer period and the actor checks the date. 0 = any time.

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

Order of the jobs in each search (matters when Max jobs is lower than the number of results).

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

Keep only jobs that list at least one of these skills (required or nice to have), e.g. "Kubernetes", "React". The exact skill name, case doesn't matter.

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

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

Return only jobs that are new or whose title, company, salary, towns, work arrangement or seniority changed since the previous run with the same Monitoring key. Unchanged jobs are free; every listing page read in this mode is charged as "Monitoring: listing page checked" (see the Pricing tab; 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 "reappeared" when they come back). 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.

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

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

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

With "Monitoring: only new or changed jobs": do not return a new job that is the same job seen in an earlier run under another ID (the employer published the ad again). Skipped jobs are not charged. Off = such jobs are returned with isRepost true and repostOf.

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

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

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

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

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

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. Most useful with "Add description and details"; listing-only runs are fast anyway. Charged as "Fast mode" per saved job (see the Pricing tab).

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

No proxy needed. Turn a proxy on only if the website starts rejecting 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
{
  "categories": [
    "python"
  ],
  "maxItems": 20,
  "maxPages": 0,
  "includeDetails": false,
  "descriptionFormat": "text",
  "descriptionMaxLength": 0,
  "onlyWithSalary": false,
  "salaryCurrency": "PLN",
  "sortBy": "default",
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "includeUnchanged": false,
  "skipReposts": false,
  "compact": false,
  "excludeEmptyFields": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "fastMode": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

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

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "categories": [
        "python"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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