# JustJoin.it Jobs Scraper (`parsebird/justjoin-jobs-scraper`) Actor
Scrape JustJoin.it tech job listings: titles, companies, salaries, skills, workplace type, and 20+ fields. Filter by keyword or Polish city.
- **URL**: https://apify.com/parsebird/justjoin-jobs-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.89 / 1,000 job scrapeds
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/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".
## 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.
The best way to integrate Actors is as follows.
- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
### JustJoin.it Jobs Scraper
Scrape tech job listings from [JustJoin.it](https://justjoin.it), Poland's largest IT job board, with **JustJoin.it Jobs Scraper**. Extract titles, companies, salaries, required skills, workplace type, and 20+ structured fields per listing — no coding or API keys required.
Search by keyword or Polish city, or feed in direct job-offer URLs — get clean, structured JustJoin.it job data including salary ranges, required skills, and full descriptions, ready for analysis or integration.
##### Copy to your AI assistant
Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.
```
Apify Actor: parsebird/justjoin-jobs-scraper. Scrapes tech job listings from JustJoin.it (justjoin.it). Call via ApifyClient: client.actor("parsebird/justjoin-jobs-scraper").call(run_input={"keywords": "React", "city": "", "maxItems": 50, "maxPages": 10, "startUrls": [], "proxyConfiguration": {"useApifyProxy": false}}). Returns fields per job: id, slug, title, company, category, workplace_type, working_time, experience, location, required_skills, nice_to_have_skills, languages, salary, employment_types, apply_url, date_posted, last_published_at, expires_at, description_text, url, source. Full API spec: https://apify.com/parsebird/justjoin-jobs-scraper/api. Get your token: https://console.apify.com/settings/integrations.
```
### What does JustJoin.it Jobs Scraper do?
**JustJoin.it Jobs Scraper** is an [Apify Actor](https://apify.com) that extracts structured job data from [JustJoin.it](https://justjoin.it), a leading tech-focused job board covering the Polish and wider European IT market. It works as a JustJoin.it API alternative — no browser automation, CAPTCHAs, or scraping expertise needed.
- 🔍 **Keyword search** — find jobs by title or skill, e.g. `React`, `Python`, `DevOps`
- 📍 **City filtering** — focus on a specific Polish city, e.g. `Warszawa`, `Kraków`, `Wrocław`
- 🔗 **Direct URL mode** — pass one or more JustJoin.it job-offer URLs to scrape specific listings
- 💰 **Salary extraction** — parses published salary ranges and employment-type breakdowns (B2B, permanent contract)
- 🧩 **Skills & languages** — required skills, nice-to-have skills, and language requirements per listing
- ⏱️ **Scheduling & monitoring** — run on a schedule to track new postings over time via [Apify's scheduler](https://docs.apify.com/platform/schedules)
- 🔌 **API & integrations** — trigger runs and pull results via the [Apify API](https://docs.apify.com/api/v2), or connect to Zapier, Make, Google Sheets, and other [Apify integrations](https://apify.com/integrations)
### What data can you extract from JustJoin.it?
| Field | Description |
|-------|-------------|
| `title` | Job title |
| `company` | Hiring company name |
| `category` | Main job category (e.g. `python`, `javascript`, `ux`) |
| `workplace_type` | Remote, hybrid, or office |
| `experience` | Seniority level (junior, mid, senior, etc.) |
| `location` | Primary city |
| `required_skills` / `nice_to_have_skills` | Required and preferred skills lists |
| `salary` | Readable salary range and period, when published |
| `employment_types` | Contract type and salary metadata (B2B, permanent) |
| `apply_url` | Direct application URL |
| `date_posted` / `expires_at` | Publication and expiration timestamps |
| `description_text` | Full plain-text job description |
### Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | array | No | `[]` | Public JustJoin.it job-detail URLs to scrape directly |
| `keywords` | string | No | `""` | Job-title or skill search term, e.g. React, Python, DevOps |
| `city` | string | No | `""` | Polish city to focus the search, e.g. Warszawa, Kraków, Wrocław |
| `maxItems` | integer | No | `50` | Maximum number of job records to save (1–10,000) |
| `maxPages` | integer | No | `10` | Maximum number of result pages to process (1–100) |
| `proxyConfiguration` | object | No | `{"useApifyProxy": false}` | Optional Apify Proxy settings |
### How to scrape JustJoin.it jobs
1. **Open JustJoin.it Jobs Scraper** in [Apify Console](https://console.apify.com) and click **Try for free**.
2. **Enter your search** — type a `keywords` term (e.g. "Python"), optionally add a `city`, or paste specific job-offer URLs into `startUrls`.
3. **Set `maxItems`** to control how many job records the run collects.
4. **Click Start** and wait for the run to finish — most runs complete in seconds to a few minutes.
5. **Download results** from the Dataset tab in JSON, CSV, Excel, or HTML, or pull them via the [API](https://docs.apify.com/api/v2).
### Output example
```json
{
"id": "6e12854a-1faa-4e45-8e45-d1b8d8ceb4bc",
"slug": "wirtualna-polska-media-product-design-gdansk-ux",
"title": "Product Design",
"company": "Wirtualna Polska Media",
"category": "ux",
"workplace_type": "hybrid",
"working_time": "full_time",
"experience": "mid",
"location": "Gdańsk",
"required_skills": ["Figma"],
"nice_to_have_skills": [],
"languages": [],
"salary": "15000 - 22000 PLN / month",
"employment_types": "permanent 15000-22000 PLN/month gross original",
"apply_url": "https://system.erecruiter.pl/FormTemplates/RecruitmentForm.aspx?WebID=ff5b58d23f0a41b98742aae11744e0a1",
"date_posted": "2026-03-14T09:00:05.898Z",
"expires_at": "2026-05-17T21:59:59.999Z",
"description_text": "About us...",
"url": "https://justjoin.it/job-offer/wirtualna-polska-media-product-design-gdansk-ux",
"source": "justjoin.it"
}
```
### How to use JustJoin.it Jobs Scraper with the API
#### Python API example
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("parsebird/justjoin-jobs-scraper").call(run_input={
"keywords": "React",
"city": "Warszawa",
"maxItems": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(f"{item['title']} — {item['company']} — {item['salary']}")
```
#### JavaScript API example
```javascript
import { ApifyClient } from "apify-client";
const client = new ApifyClient({ token: "YOUR_API_TOKEN" });
const run = await client.actor("parsebird/justjoin-jobs-scraper").call({
keywords: "React",
city: "Warszawa",
maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.log(`${item.title} — ${item.company} — ${item.salary}`);
});
```
Get your API token at [console.apify.com/settings/integrations](https://console.apify.com/settings/integrations). See the full [API documentation](https://apify.com/parsebird/justjoin-jobs-scraper/api) for details.
### Use cases
- **Job market research** — track hiring trends, in-demand skills, and salary ranges across the Polish and European tech market.
- **Recruitment sourcing** — build a feed of open roles matching specific skills or cities for candidate outreach.
- **Salary benchmarking** — collect published salary ranges to benchmark compensation for a role or region.
- **Competitive intelligence** — monitor which companies are hiring, for which roles, and how fast they're growing headcount.
- **Lead generation** — identify companies actively hiring as prospects for recruitment, HR tech, or B2B sales.
### How it works
1. **Search** — the actor queries JustJoin.it's job listing feed with your `keywords` and `city` filters, paginating until `maxItems` or `maxPages` is reached.
2. **Direct URLs** — if `startUrls` is set, the actor scrapes exactly those job-offer pages instead of searching.
3. **Detail fetch** — for each matched listing, the actor fetches the full job record, including salary, skills, languages, and the complete description.
4. **Data transformation** — raw fields are normalized into a clean, consistent schema (HTML stripped from descriptions, salary formatted as a readable range).
5. **Output** — results are pushed to the Apify dataset, downloadable as JSON, CSV, Excel, or via the API.
### How much does it cost to scrape JustJoin.it?
This actor uses [pay-per-event pricing](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) — you're charged only for job records actually delivered, not for compute time.
| Event | Price per event | Price per 1,000 |
|-------|-----------------|------------------|
| `job-scraped` (Free plan) | $0.00099 | **$0.99** |
| `job-scraped` (Bronze / Silver / Gold plan) | $0.00089 | **$0.89** |
A run collecting 500 job listings costs under $0.50. New Apify accounts get [free platform credits](https://apify.com/pricing) to try the actor before committing to a paid plan.
### FAQ
**Does this actor need a proxy?**
No. JustJoin.it's public listing data is accessible without a proxy. The `proxyConfiguration` input is available for runs that specifically need Apify Proxy.
**Can I search by both keyword and city at the same time?**
Yes — set both `keywords` and `city` to combine filters, e.g. `keywords: "Python"` and `city: "Kraków"`.
**What happens if I provide `startUrls`?**
When `startUrls` is set, the actor scrapes exactly those job-offer URLs and ignores `keywords` and `city`.
**How many jobs can I collect per run?**
Up to 10,000 via `maxItems`, paginated through up to 100 result pages via `maxPages`.
**Can I run this on a schedule?**
Yes — use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the actor daily, weekly, or at any interval, and monitor new JustJoin.it postings automatically.
**Does the output include the full job description?**
Yes — `description_text` contains the complete job description with HTML tags stripped, in plain text.
### Is it legal to scrape JustJoin.it?
Yes. This actor only accesses publicly available job listing data that JustJoin.it and employers have made public for recruitment purposes — no login, paywall, or private data is involved. Scraping publicly accessible data is generally lawful, as covered in [Apify's guide to the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/). Users are responsible for ensuring their use of the collected data complies with applicable laws and JustJoin.it's Terms of Service.
### Related Actors
- [Hiring.cafe Jobs Scraper](https://apify.com/parsebird/hiring-cafe-scraper) — job listings aggregated from 46+ ATS platforms
- [Dice Jobs Scraper](https://apify.com/parsebird/dice-jobs-scraper) — US tech job listings
- [Wellfound Jobs Scraper](https://apify.com/parsebird/wellfound-jobs-scraper) — startup and tech jobs
- [Xing Jobs Scraper](https://apify.com/parsebird/xing-jobs-scraper) — European job listings
Found an issue or have a feature request? Open an issue on the Actor's Issues tab in Apify Console — feedback helps prioritize improvements.
# Actor input Schema
## `startUrls` (type: `array`):
Public JustJoin.it job-offer URLs to scrape directly. When set, the actor scrapes only these job offers and ignores Keywords/City.
## `keywords` (type: `string`):
Job-title or skill search term, for example React, Python, or DevOps.
## `city` (type: `string`):
City name to focus the listing collection, for example Warszawa, Kraków, or Wrocław.
## `maxItems` (type: `integer`):
Maximum number of job records to save.
## `maxPages` (type: `integer`):
Maximum number of result pages to process.
## `proxyConfiguration` (type: `object`):
Optional Apify Proxy settings for runs that need them.
## Actor input object example
```json
{
"startUrls": [],
"keywords": "React",
"city": "",
"maxItems": 50,
"maxPages": 10,
"proxyConfiguration": {
"useApifyProxy": false
}
}
```
# Actor output Schema
## `dataset` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"startUrls": [],
"keywords": "React",
"city": "",
"maxItems": 50,
"maxPages": 10,
"proxyConfiguration": {
"useApifyProxy": false
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/justjoin-jobs-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"startUrls": [],
"keywords": "React",
"city": "",
"maxItems": 50,
"maxPages": 10,
"proxyConfiguration": { "useApifyProxy": False },
}
# Run the Actor and wait for it to finish
run = client.actor("parsebird/justjoin-jobs-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 '{
"startUrls": [],
"keywords": "React",
"city": "",
"maxItems": 50,
"maxPages": 10,
"proxyConfiguration": {
"useApifyProxy": false
}
}' |
apify call parsebird/justjoin-jobs-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/justjoin-jobs-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 ` 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/Xnz3CEgNNTJM32MKg/builds/NG8r7BpIyMFOnejoE/openapi.json