# JustJoin.it Scraper (`solidcode/justjoin-it-scraper`) Actor

\[💰 $0.95 / 1K] Extract IT jobs from JustJoin.it — salaries in the posted pay period, skills with proficiency levels, company, location, and apply route. Search by keyword and city, filter by category, seniority, contract type, and remote/hybrid/office.

- **URL**: https://apify.com/solidcode/justjoin-it-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 59 total users, 15 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 1,000 results

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

Pull IT job listings from JustJoin.it at scale — disclosed salary ranges in the employer's own pay period, a 1-5 proficiency level on every required skill, Polish contract-type breakdowns, geo-coordinates, and the apply route for every role across the Polish and Central European tech market — including the employer's own apply link on the 81% of offers that take applications off-platform. Built for tech recruiters, sourcers, salary-benchmarking analysts, and developers job-hunting in the CEE market who need structured salary and skill data without copy-pasting one offer page at a time.

### Why This Scraper?

- **Real disclosed salary ranges, with the employer's own pay period** — every job that publishes pay returns `salaryFrom`, `salaryTo`, `salaryCurrency` and `salaryUnit` exactly as posted (PLN, EUR, USD, GBP; hourly, daily, monthly or yearly), never a converted estimate and never re-based to a different period.
- **A proficiency level on every required skill** — in a 780-job sample all 4,618 `requiredSkills` entries carried the employer's wanted level on a 1-5 scale (Python: 5, Django: 4), averaging 5.9 skills per job across 1,134 distinct technologies. `niceToHaveSkills` uses the same name-plus-level shape, but JustJoin.it employers populate it on only about 1% of offers.
- **Geo-coordinates on 100% of listings** — latitude, longitude and city on every row, spanning 59 cities in a single 780-job pull, ready to map or cluster. A street address comes with the roughly 72% of jobs whose employer published one, and is empty rather than a filler character on the rest. The ISO country code arrives with the full-description option switched on.
- **Polish/CEE contract-type breakdown** — B2B, Permanent (UoP), Mandate contract, Specific-task contract, and Internship captured per job, with salary attached to each contract type, plus a resolved `contractTypes` list so open-to-negotiation roles are never mistaken for non-matches.
- **25 named tech categories** — Python, Java, JavaScript, DevOps, Data, AI/ML, Testing, Mobile, Security, PHP, Ruby, Go, Scala, C/C++, .NET, UX/UI, PM, Architecture, ERP, Analytics, Game, HTML, Admin, Support, and Other.
- **6 seniority levels** — filter to Intern, Junior, Mid, Senior, Team Leader / Manager, or C-level roles.
- **Remote / Hybrid / Office working-mode filter, plus CEFR language requirements** — each job lists the languages the employer expects with a CEFR level from A2 to C2 across 12 language codes (English and Polish dominate, then German, French, Portuguese, Danish, Italian, Norwegian), so you can target fully-remote roles that accept a B2 English speaker in one pass.
- **The apply route on every row** — `applyMethod` is filled on 100% of jobs and splits them cleanly: `external` (81% of 3,265 offers measured across 15 categories) means the employer takes applications on their own site, and those roles carry the employer's `applyUrl`; `form` (the other 19%) means applications go through JustJoin.it's in-platform form, so there is no external URL to capture.
- **Up to 10,000 results per search** with a one-toggle full-description option that adds 7 fields at once — description HTML and plain text, `applyUrl`, `companyUrl`, `companySize`, `country` and the live/closed `isActive` flag — or switch it off for faster bulk pulls.

### Use Cases

**Tech Recruitment & Sourcing**

- Build candidate-facing role lists filtered by stack, seniority, and city
- Surface fully-remote roles open to your candidates' languages
- Track competitor hiring by company across categories
- Capture apply links for direct candidate referrals

**Salary Benchmarking**

- Compare disclosed B2B vs Permanent pay for the same role
- Benchmark salary ranges by city, seniority, and tech category
- Track pay movements over time with repeated newest-first pulls
- Map salary against required skill levels

**Market Research & Talent Analytics**

- Measure demand for specific frameworks and languages across the CEE market
- Map hiring density by city using per-listing geo-coordinates
- Quantify remote vs hybrid vs office offerings by category
- Profile company sizes hiring for a given stack

**Competitive Intelligence**

- Monitor a competitor's open roles, stack, and seniority mix
- Detect new openings the day they go live with newest-first sorting
- Track which contract types competitors offer in your market

**Job Seekers**

- Filter to remote, salary-disclosed roles matching your skills
- Sort by highest salary to surface top-of-market openings
- Pull full job descriptions and apply links for shortlisted roles

### Getting Started

#### Simple keyword search

```json
{
    "keywords": "Python",
    "maxItems": 50
}
```

#### Keyword, city, category, and seniority

```json
{
    "keywords": "React",
    "city": "Warszawa",
    "categories": ["javascript"],
    "seniority": ["senior"],
    "workingMode": ["remote"],
    "withSalaryOnly": true,
    "maxItems": 200
}
```

#### Start URLs with filters and a result cap

```json
{
    "startUrls": [
        "https://justjoin.it/job-offers/warszawa/python",
        "https://justjoin.it/job-offer/example-senior-data-engineer"
    ],
    "employmentType": ["b2b", "permanent"],
    "sortBy": "salary-desc",
    "includeDescription": false,
    "maxItems": 500
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `keywords` | string | `"Python"` | Search term for job titles, skills, or companies (e.g. "React", "DevOps"). Leave empty to browse all jobs. |
| `city` | string | `""` | City name to filter by (e.g. "Warszawa", "Kraków", "Wrocław", "Berlin"). Also includes nearby jobs within ~30 km of the city. Leave empty for all locations. |
| `startUrls` | string\[] | `[]` | Paste full JustJoin.it search or job-offer URLs to scrape directly. Used in addition to the keyword/city search. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | select\[] | `[]` | Tech categories to include: AI/ML, JavaScript, HTML, PHP, Ruby, Python, Java, .NET, Scala, C / C++, Mobile, Testing, DevOps, Admin, UX/UI, Project Manager, Game, Analytics, Security, Data, Go, Support, ERP, Architecture, Other. Leave empty for all. |
| `seniority` | select\[] | `[]` | Experience levels: Intern, Junior, Mid, Senior, Team Leader / Manager, C-level. Leave empty for all. |
| `employmentType` | select\[] | `[]` | Contract types: B2B, Permanent (UoP), Mandate contract, Internship, Specific-task contract. Leave empty for all. |
| `workingMode` | select\[] | `[]` | Work arrangements: Remote, Hybrid, Office. Leave empty for all. |
| `withSalaryOnly` | boolean | `false` | When on, only include jobs that publish a salary range. |
| `sortBy` | select | `Default (relevance)` | Result order: Default (relevance), Newest first, Highest salary first, Lowest salary first. "Newest first" uses JustJoin.it's own newest ranking, which puts freshly published jobs ahead of older listings an employer has renewed. |

#### Output & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDescription` | boolean | `true` | Include each job's full description text and HTML. Turn off for a faster, lighter run when you only need summary fields. |
| `maxItems` | integer | `100` | Maximum number of jobs to collect. Set to 0 for no limit (everything matching your search). |

### Output

Each job posting is one flat row. Here's a representative result with `includeDescription` on. Seven of these fields — `descriptionHtml`, `descriptionText`, `applyUrl`, `companyUrl`, `companySize`, `country` and `isActive` — come from the full job detail, so they are `null` (or absent) on runs with `includeDescription` off:

```json
{
    "id": "a1b2c3d4-1234-5678-90ab-cdef12345678",
    "slug": "senior-python-engineer-acme-warszawa",
    "url": "https://justjoin.it/job-offer/senior-python-engineer-acme-warszawa",
    "title": "Senior Python Engineer",
    "company": "Acme Tech",
    "companyUrl": "https://justjoin.it/companies/acme-tech",
    "companySize": "100 - 499",
    "companyLogo": "https://justjoin.it/logos/acme.png",
    "category": "python",
    "experience": "senior",
    "salary": "20,000 - 28,000 PLN / Month",
    "salaryFrom": 20000,
    "salaryTo": 28000,
    "salaryCurrency": "PLN",
    "salaryUnit": "Month",
    "employmentTypes": [
        { "type": "b2b", "from": 20000, "to": 28000, "fromPerUnit": 20000, "toPerUnit": 28000, "currency": "PLN", "currencySource": "original", "unit": "Month", "gross": false }
    ],
    "contractTypes": ["b2b"],
    "openToAnyContractType": false,
    "workingMode": "remote",
    "workingTime": "full_time",
    "city": "Warszawa",
    "street": "Krucza 50",
    "country": "PL",
    "latitude": 52.2297,
    "longitude": 21.0122,
    "locations": [
        { "city": "Warszawa", "street": "Krucza 50", "latitude": 52.2297, "longitude": 21.0122, "slug": "warszawa" }
    ],
    "requiredSkills": [
        { "name": "Python", "level": 5 },
        { "name": "Django", "level": 4 }
    ],
    "niceToHaveSkills": [
        { "name": "Kubernetes", "level": 3 }
    ],
    "languages": [
        { "code": "en", "level": "B2" }
    ],
    "remoteInterview": true,
    "openToHireUkrainians": true,
    "promoted": false,
    "isSuperOffer": false,
    "applyMethod": "external",
    "applyUrl": "https://acme-tech.com/careers/senior-python",
    "isActive": true,
    "datePosted": "2026-05-20T08:00:00Z",
    "lastPublishedAt": "2026-05-22T08:00:00Z",
    "expiresAt": "2026-06-21T08:00:00Z",
    "descriptionHtml": "<p>We are looking for a Senior Python Engineer...</p>",
    "descriptionText": "We are looking for a Senior Python Engineer...",
    "source": "justjoin.it"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique job offer identifier |
| `slug` | string | URL slug for the offer |
| `url` | string | Public JustJoin.it listing URL |
| `title` | string | Job title |
| `category` | string | Tech category (e.g. python, devops) |
| `experience` | string | Seniority level (intern, junior, mid, senior, manager, c_level) |
| `workingMode` | string | remote, hybrid, or office |
| `workingTime` | string | Full-time or part-time |
| `source` | string | Source marker ("justjoin.it") |

#### Company

| Field | Type | Description |
|-------|------|-------------|
| `company` | string | Employer / company name |
| `companyLogo` | string | Company logo URL |
| `companyUrl` | string | Company profile URL. **Requires `includeDescription`.** Even then, JustJoin.it publishes it on roughly 3 in 10 offers; `null` otherwise |
| `companySize` | string | Company size band (e.g. "100 - 499"). **Requires `includeDescription`**, and is published on roughly the same 3 in 10 offers as `companyUrl` |

#### Salary

| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | Human-readable salary range summary, e.g. `20,000 - 28,000 PLN / Month` |
| `salaryFrom` | number | Lower bound of the disclosed salary, in `salaryUnit` |
| `salaryTo` | number | Upper bound of the disclosed salary, in `salaryUnit` |
| `salaryCurrency` | string | Salary currency (PLN, EUR, USD, GBP) |
| `salaryUnit` | string | Pay period the figures are quoted in: `Hour`, `Day`, `Month` or `Year` |
| `contractTypes` | string\[] | Every contract type the job is available on, deduplicated and ready to filter on: `b2b`, `permanent`, `mandate_contract`, `contract`, `internship`. When the employer has not restricted the contract type, all five are listed. |
| `openToAnyContractType` | boolean | `true` when the employer named no specific contract type and is open to any of them (JustJoin.it labels these offers "Any"). `false` when the types in `contractTypes` were stated explicitly. |
| `employmentTypes` | object\[] | Contract types with per-type salary, currency, unit, and gross flag. `fromPerUnit`/`toPerUnit` are the figures as posted (in that entry's `unit`); `from`/`to` are the same pay expressed as a monthly equivalent, which is what JustJoin.it ranks and filters on. They match when `unit` is `Month`. May include a converted mirror of a row alongside the employer's original figure — the original always has `currencySource: "original"`. |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | Primary city |
| `street` | string | Street address, or empty when the employer published none (about 28% of jobs) |
| `country` | string | Uppercase ISO 3166-1 alpha-2 country code (e.g. `PL`, `GB`, `PT`). **Requires `includeDescription`** |
| `latitude` | number | Geo latitude |
| `longitude` | number | Geo longitude |
| `locations` | object\[] | All listed work locations with city, street, and coordinates |

#### Skills & Languages

| Field | Type | Description |
|-------|------|-------------|
| `requiredSkills` | object\[] | Must-have skills, each with name and proficiency level |
| `niceToHaveSkills` | object\[] | Nice-to-have skills, same name-and-level shape as `requiredSkills`. JustJoin.it employers rarely fill this in — expect `[]` on about 99% of jobs |
| `languages` | object\[] | Required languages, each with code and proficiency level |
| `remoteInterview` | boolean | Whether a remote interview is available |
| `openToHireUkrainians` | boolean | Whether the employer is open to hiring Ukrainians |

#### Dates & Apply

| Field | Type | Description |
|-------|------|-------------|
| `applyMethod` | string | How the employer takes applications. Two values only: `external` (their own site) or `form` (JustJoin.it's in-platform form). Filled on 100% of rows |
| `applyUrl` | string | The employer's external application URL. **Requires `includeDescription`**, and is `null` on every `form` job — about 1 in 5 — because those apply on JustJoin.it itself via the `url` field |
| `isActive` | boolean | Whether the listing is still open. **Requires `includeDescription`** |
| `datePosted` | string | The publication date JustJoin.it shows on the offer page. Refreshed when an employer renews a listing, so it can be later than the job first appeared |
| `lastPublishedAt` | string | When this listing was published in its own right. Matches `datePosted` until the employer renews the ad, and is the field "Newest first" ranks on |
| `expiresAt` | string | Listing expiry date |
| `promoted` | boolean | Promoted listing flag |
| `isSuperOffer` | boolean | Featured "super offer" flag |

#### Description

Populated when `includeDescription` is on; `null` when it is off.

| Field | Type | Description |
|-------|------|-------------|
| `descriptionHtml` | string | Full job description in HTML |
| `descriptionText` | string | Full job description in plain text |

### Tips for Best Results

- **Start small, then combine inputs** — set `maxItems` to 25-50 on your first run to confirm the data matches your needs, then scale up and mix a keyword, a city, several categories and start URLs in one run; results are de-duplicated across every entry point. Pairing `seniority` with a category (Senior + Data + Remote) gives a focused, mappable slice, and "Highest salary first" puts top-of-market roles at the front of the export.
- **Always group on `salaryUnit` before comparing pay** — turn on `withSalaryOnly` to drop the undisclosed rows, then read the unit: of 434 salaried jobs we measured, 51% quoted a monthly figure and 45% an hourly one, so a raw `salaryFrom` comparison mixes two different scales.
- **Keep `includeDescription` on whenever you need company or apply data** — switching it off makes large runs noticeably quicker and still returns salary, skills, contract types, coordinates, dates and `applyMethod`, but it blanks all seven detail fields: `descriptionHtml`, `descriptionText`, `applyUrl`, `companyUrl`, `companySize`, `country` and `isActive`.
- **Split your outreach on `applyMethod`** — `external` jobs hand you the employer's own `applyUrl` for direct contact, while `form` jobs (about 1 in 5) accept applications only inside JustJoin.it, so route those to the row's `url` instead of treating the missing `applyUrl` as a gap.
- **"Newest first" ranks on `lastPublishedAt`, not `datePosted`** — a job an employer renewed this morning carries today's `datePosted` even though the ad has been live for weeks. In a recent "Newest first" pull every one of the top 300 jobs had gone live within 7 days on `lastPublishedAt`, against 84% older than that in a plain unsorted pull of the same size. Sort your export on `lastPublishedAt` to reproduce the run order, or on `datePosted` to rank by the date candidates see on the listing.
- **Read `employmentTypes` for true compensation** — a single job often lists different pay for B2B vs Permanent; the per-type array shows each figure with its currency and pay period, so you compare like-for-like. Use `from`/`to` when you want every offer on one monthly scale, and `fromPerUnit`/`toPerUnit` when you want the figure as the employer wrote it. The array also includes converted mirrors of each row; filter to entries where `currencySource` is `"original"` to keep only the employer's posted figures.
- **Filter contract type on `contractTypes`, not the raw type list** — many CEE employers leave the contract open to negotiation instead of naming one, and JustJoin.it returns those jobs in every contract-type search. `contractTypes` already resolves them to the full set, so a B2B run gives you `"b2b"` on every row. Check `openToAnyContractType` when you want only the employers who committed to B2B in writing, and expect these open-contract jobs to be the ones without a published salary.

### Pricing

**From $0.95 per 1,000 results** — competitively priced for the CEE tech-hiring market. No compute charges — you only pay per result returned. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.11 | $0.10 | $0.10 |
| 1,000 | $1.10 | $1.05 | $1.00 | $0.95 |
| 10,000 | $11.00 | $10.50 | $10.00 | $9.50 |
| 100,000 | $110.00 | $105.00 | $100.00 | $95.00 |

A "result" is one job posting row in the output dataset. There are no separate compute or per-event charges — you pay only for the jobs returned.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom integrations on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate recruitment research, salary benchmarking, and labor-market analysis. Users are responsible for complying with applicable laws and JustJoin.it's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data in line with applicable privacy regulations such as GDPR.

# Actor input Schema

## `keywords` (type: `string`):

Search term for job titles, skills, or companies (e.g. 'React', 'Python', 'DevOps'). Leave empty to browse all jobs.

## `city` (type: `string`):

City name to filter by (e.g. 'Warszawa', 'Kraków', 'Wrocław', 'Berlin'). Also includes nearby jobs within ~30 km of the city. Leave empty to include all locations.

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

Optional: paste full JustJoin.it search or job-offer URLs to scrape directly (e.g. 'https://justjoin.it/job-offers/warszawa/python'). When provided, these are used in addition to the keyword/city search above.

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

Only include jobs in these tech categories. Leave empty for all categories.

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

Only include jobs at these experience levels. Leave empty for all levels.

## `employmentType` (type: `array`):

Only include jobs offering these contract types. Leave empty for all types.

## `workingMode` (type: `array`):

Only include jobs with these work arrangements. Leave empty for all.

## `withSalaryOnly` (type: `boolean`):

When enabled, only include job listings that publish a salary range.

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

Order in which jobs are collected. "Newest first" uses JustJoin.it's own newest ranking, which puts freshly published jobs ahead of older listings an employer has renewed — so it can differ slightly from the datePosted column, which is refreshed on renewal.

## `includeDescription` (type: `boolean`):

When enabled, each job includes its full description (text and HTML) plus the apply URL, company profile URL, company size, country code, and whether the listing is still open. Disable for a faster, lighter run — those seven fields come back empty.

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

Maximum number of job listings to collect. Set to 0 for no limit (collect everything matching your search).

## Actor input object example

```json
{
  "keywords": "Python",
  "city": "",
  "startUrls": [],
  "categories": [],
  "seniority": [],
  "employmentType": [],
  "workingMode": [],
  "withSalaryOnly": false,
  "sortBy": "default",
  "includeDescription": true,
  "maxItems": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of jobs with key fields like title, company, salary, location, and link.

## `details` (type: `string`):

Full per-job detail rows including tech stack, employment types, working mode, and 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 = {
    "keywords": "Python",
    "city": "",
    "startUrls": [],
    "categories": [],
    "seniority": [],
    "employmentType": [],
    "workingMode": [],
    "withSalaryOnly": false,
    "sortBy": "default",
    "includeDescription": true,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "keywords": "Python",
    "city": "",
    "startUrls": [],
    "categories": [],
    "seniority": [],
    "employmentType": [],
    "workingMode": [],
    "withSalaryOnly": False,
    "sortBy": "default",
    "includeDescription": True,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "keywords": "Python",
  "city": "",
  "startUrls": [],
  "categories": [],
  "seniority": [],
  "employmentType": [],
  "workingMode": [],
  "withSalaryOnly": false,
  "sortBy": "default",
  "includeDescription": true,
  "maxItems": 100
}' |
apify call solidcode/justjoin-it-scraper --silent --output-dataset

```

## MCP server setup

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