# Pracuj.pl Scraper (`solidcode/pracuj-pl-scraper`) Actor

\[💰 $1.8 / 1K]  Extract job listings from Pracuj.pl — Poland's largest job board. Search 60,000+ offers by keyword, location, category, contract type, and work mode. Returns titles, companies, salaries, descriptions, requirements, benefits, and contacts.

- **URL**: https://apify.com/solidcode/pracuj-pl-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Pracuj.pl Scraper

Pull job postings from **Pracuj.pl** — Poland's largest job board — at scale. Get titles, companies, structured salaries, multi-city locations, full descriptions, requirements / responsibilities / benefits, direct apply links, and recruiter contacts across roughly 80,000 active offers nationwide. Built for Polish recruiters, staffing firms, and talent intelligence teams who need fresh CEE labor-market data without wrestling with a Polish-language site one page at a time.

### Why This Scraper?

- **35 verified job categories** — IT software development, finance & accounting, sales, marketing, engineering, healthcare, logistics, construction, public sector, and 26 more from Pracuj.pl's own taxonomy. Combine several in a single run.
- **11 position levels and 8 contract types** — slice senior B2B from junior employment contracts in one query; covers intern, assistant, junior, mid, senior, expert, team leader, manager, director, C-level, and blue-collar.
- **Structured salary with canonical period and currency** — every offer that publishes a salary returns `{min, max, currency, period, displayText}`. Currency is PLN / EUR / USD; period is normalized to one of `hour`, `day`, `week`, `month`, `year`, or `once` — never the raw Polish strings — ready for compensation dashboards.
- **Three parallel content arrays** — `requirements`, `responsibilities`, and `benefits` arrive pre-split as clean bullet lists, not a wall of HTML. Average 10 requirements and 7 responsibilities per posting.
- **Multi-city postings collapsed into one row** — nationwide retail and banking roles republished across up to 37 cities arrive as a single row with a bounded `locations[]` array, not 37 near-duplicates. You pay for unique jobs, not city copies.
- **Direct apply URLs plus one-click apply flags** — `applyUrl` returns the external ATS form (Greenhouse, Traffit, SmartRecruiters, and similar) when the employer wires one through, otherwise the Pracuj.pl-hosted apply page. `isOneClickApply` and `isOptionalCv` booleans let you spot quick-apply roles instantly.
- **Polish-friendly location input** — type `Warszawa`, `Kraków`, `Wrocław`, `Gdańsk`, `Łódź`, or any of 16 voivodeships in Polish characters. Combine with a `+ 10 / 20 / 30 / 50 km` radius widget that mirrors Pracuj.pl's own search.
- **`startUrls` power-user mode** — paste any pracuj.pl listing URL with your filters already dialed in (e.g. `/praca/javascript;kw/warszawa;wp?et=17&p=7`) and the actor reproduces it exactly, skipping the guided fields.
- **Flat $1.80 per 1,000 results — detail-rich rows included** — the competing actor charges $3 per 1k for list-only rows and $5 per 1k once you turn on detail enrichment. Here, full descriptions and contacts are on by default at one flat rate.

### Use Cases

**Recruiting & Sourcing**
- Build candidate-targeting lists by combining role, seniority, and city
- Monitor competitor hiring in IT software development, finance, or sales
- Track new B2B contracts in Warszawa, Kraków, and Wrocław for tech sourcing
- Surface fresh openings every morning to feed your ATS

**Market & Salary Intelligence**
- Compare salary ranges by position level, contract type, and voivodeship
- Benchmark Polish IT, finance, and manufacturing compensation across cities
- Track demand for specific tech stacks (`java`, `python`, `react`, `sap`)
- Detect seasonal hiring waves by re-running with `publishedWithin: "7"`

**Job-Board & ATS Integration**
- Aggregate Polish listings into a niche vertical board (tech, healthcare, finance)
- Enrich existing job feeds with structured salary and category data
- Power CEE coverage in a pan-European job aggregator
- Schedule daily runs to keep listings current

**Candidate-Side Automation**
- Build automated job-search pipelines filtered to remote + senior + B2B
- Pull only postings published in the last 24 hours for "new today" alerts
- Match jobs against a skills list using the `requirements` array

**Academic & Policy Research**
- Analyze the Polish labor market by category, region, and contract type
- Study the share of remote vs hybrid vs office roles over time
- Quantify the gap between salary-disclosed and salary-hidden offers

### Getting Started

#### Simple Keyword Search

The fastest way to start — one keyword, default limits:

```json
{
    "searchQueries": ["javascript"],
    "maxResults": 100
}
````

#### Keyword + Location + Radius (Remote Roles in Warszawa)

Narrow to remote roles within 30 km of the capital:

```json
{
    "searchQueries": ["python developer"],
    "location": "Warszawa",
    "radius": "30",
    "workModes": ["home-office"],
    "maxResults": 200
}
```

#### Filter Combo — Senior B2B in IT with Disclosed Salary

Ideal for compensation benchmarking:

```json
{
    "searchQueries": ["backend"],
    "category": ["it-software-development"],
    "positionLevels": ["senior", "expert"],
    "contractTypes": ["b2b"],
    "withSalaryOnly": true,
    "publishedWithin": "14",
    "maxResults": 500
}
```

#### Paste a Pre-Built Pracuj.pl URL

Already filtered a search in your browser? Drop the URL in directly:

```json
{
    "startUrls": [
        "https://www.pracuj.pl/praca/javascript;kw/warszawa;wp?et=17&p=7"
    ],
    "maxResults": 200
}
```

### Input Reference

#### Search & Location

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["javascript"]` | Polish or English keywords. Each runs as its own search; rows matching multiple keywords are deduplicated automatically. Leave empty to scrape the unfiltered all-Poland listing. |
| `location` | string | `null` | City (`Warszawa`, `Kraków`, `Gdańsk`) or voivodeship (`mazowieckie`, `małopolskie`). Polish characters accepted. Empty = all of Poland. |
| `radius` | select | `Exact area only (0 km)` | Expand the search by `+ 10 km`, `+ 20 km`, `+ 30 km`, or `+ 50 km`. Mirrors the Pracuj.pl radius widget. Ignored when Location is empty. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | select\[] | `[]` | One or more of 35 job categories: IT — Software Development, Finance & Economics, Sales, Marketing, Engineering, Production, Health / Beauty / Recreation, and more. |
| `contractTypes` | select\[] | `[]` | One or more of 8 contract types: Employment contract, B2B contract, Mandate contract, Specific-task contract, Substitution, Agency, Temporary employment, Internship. |
| `workModes` | select\[] | `[]` | One or more of 4 work modes: Office, Hybrid, Remote, Mobile / field work. |
| `workSchedule` | select\[] | `[]` | One or more of 3 schedules: Full-time, Part-time, Additional / temporary. |
| `positionLevels` | select\[] | `[]` | One or more of 11 seniority levels: Intern, Assistant, Junior, Mid, Senior, Expert, Team leader, Manager, Director, President / C-level, Blue-collar worker. |
| `publishedWithin` | select | `Any (all active offers)` | Recency window: Last 24 hours, 3 days, 7 days, 14 days, or 30 days. |
| `withSalaryOnly` | boolean | `false` | Skip offers that don't publish a salary range. Useful for compensation research. |

#### Source URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Power-user input. Paste Pracuj.pl listing URLs (`/praca/javascript;kw/warszawa;wp`) or individual offer URLs (`/praca/...,oferta,1234567`). When provided, these override the guided Search and Filters fields above. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of job postings to collect across all searches and URLs. Set to `0` for no cap (an internal safety limit of 100,000 still applies). Results are collected in full pages of ~50 offers, so the final page may overshoot this number by a few rows. |

### Output

One row per unique job posting. Multi-location postings (e.g. a nationwide retail role published in 25 cities) arrive as a single row with every city listed in the `locations` array.

```json
{
    "id": "12345678-90ab-cdef-1234-567890abcdef",
    "partitionId": 1004811129,
    "title": "Senior Python Developer",
    "url": "https://www.pracuj.pl/praca/senior-python-developer-warszawa,oferta,1004811129",
    "company": {
        "name": "Acme Software Sp. z o.o.",
        "url": "https://www.pracuj.pl/praca/acme-software;p,123456",
        "website": null,
        "logoUrl": "https://static.pracuj.pl/employers/123456/logo.png",
        "id": 123456
    },
    "salary": {
        "min": 18000,
        "max": 24000,
        "currency": "PLN",
        "period": "month",
        "displayText": "18 000–24 000 zł brutto / mies."
    },
    "contractTypes": ["b2b", "permanent"],
    "workModes": ["hybrid"],
    "workSchedules": ["full-time"],
    "positionLevels": ["senior"],
    "categories": ["it-software-development"],
    "locations": [
        {
            "city": "Warszawa",
            "region": "mazowieckie",
            "country": "Poland",
            "isWholePoland": false,
            "displayWorkplace": "Warszawa, Mokotów",
            "partitionId": 1004811129,
            "url": "https://www.pracuj.pl/praca/senior-python-developer-warszawa,oferta,1004811129"
        }
    ],
    "primaryLocation": {
        "city": "Warszawa",
        "region": "mazowieckie",
        "country": "Poland",
        "isWholePoland": false,
        "displayWorkplace": "Warszawa, Mokotów",
        "partitionId": 1004811129,
        "url": "https://www.pracuj.pl/praca/senior-python-developer-warszawa,oferta,1004811129"
    },
    "descriptionSnippet": "We are looking for an experienced Python engineer to join our platform team...",
    "descriptionText": "Responsibilities:\n- Design and ship backend services in Python 3.12\n- Own deployment and observability\n\nRequirements:\n- 5+ years of Python experience\n- Strong SQL and Postgres\n...",
    "requirements": [
        "5+ years of Python experience",
        "Strong SQL and Postgres knowledge",
        "Experience with AWS or GCP"
    ],
    "responsibilities": [
        "Design and ship backend services in Python 3.12",
        "Own deployment and observability of your services"
    ],
    "benefits": [
        "Private medical care",
        "Multisport card",
        "Annual training budget"
    ],
    "applyUrl": "https://acme-software.com/careers/apply/python-senior",
    "applyEmail": null,
    "contactPhone": null,
    "isOneClickApply": false,
    "isOptionalCv": false,
    "isRemoteWorkAllowed": false,
    "isSuperOffer": true,
    "postedAt": "2026-05-20T08:00:00Z",
    "expiresAt": "2026-06-19T22:59:59Z",
    "searchQuery": "python developer",
    "sourceListUrl": "https://www.pracuj.pl/praca/python%20developer;kw/warszawa;wp?rd=30&pn=1",
    "scrapedAt": "2026-05-23T14:30:00Z",
    "sourcePlatform": "pracuj.pl"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Stable identifier for the grouped posting (`groupId`). |
| `partitionId` | number | Numeric Pracuj.pl offer ID of the primary location. |
| `title` | string | Job title as published. |
| `url` | string | Canonical detail URL of the primary location. |
| `descriptionSnippet` | string | Short list-page teaser. |
| `descriptionText` | string | Full plain-text description, composed across every detail-page section (responsibilities, requirements, benefits, about-us, etc.) into one readable block — typically 1.5–4 KB per posting. |
| `postedAt` | string | ISO 8601 timestamp when the posting was last (re-)published. |
| `expiresAt` | string | ISO 8601 timestamp when the posting expires. |
| `scrapedAt` | string | ISO 8601 timestamp of data collection. |
| `sourcePlatform` | string | Always `"pracuj.pl"`. |

#### Company

| Field | Type | Description |
|-------|------|-------------|
| `company.name` | string | Employer's display name. |
| `company.url` | string | Pracuj.pl company-profile URL. |
| `company.website` | string | Company's own site, when available. |
| `company.logoUrl` | string | Company logo image URL. |
| `company.id` | number | Pracuj.pl numeric employer ID. |

#### Salary

| Field | Type | Description |
|-------|------|-------------|
| `salary.min` | number | Lower bound of published salary (null when not disclosed). |
| `salary.max` | number | Upper bound of published salary (null when not disclosed). |
| `salary.currency` | string | Currency code — typically `PLN`, also `EUR` and `USD`. |
| `salary.period` | string | Pay period — one of `hour`, `day`, `week`, `month`, `year`, or `once`. Normalized from Pracuj.pl's mixed Polish / English source values, so you never have to handle both. |
| `salary.displayText` | string | Raw salary string as shown on Pracuj.pl. |

#### Locations

| Field | Type | Description |
|-------|------|-------------|
| `locations` | object\[] | Every city the posting was published in (bounded — typically 1–5, up to ~37 for nationwide roles). |
| `locations[].city` | string | City name. |
| `locations[].region` | string | Polish voivodeship. |
| `locations[].country` | string | Always `"Poland"`. |
| `locations[].isWholePoland` | boolean | `true` when Pracuj.pl tags the role as also acceptable nationwide (can co-exist with a specific city). |
| `locations[].url` | string | Direct URL to that location's offer copy. |
| `primaryLocation` | object | First entry of `locations` flattened to the top level for convenient tabular views. |

#### Categorization

| Field | Type | Description |
|-------|------|-------------|
| `categories` | string\[] | One or more of the 35 Pracuj.pl category slugs (e.g. `it-software-development`). |
| `contractTypes` | string\[] | One or more of 8 contract slugs (`b2b`, `permanent`, `mandate`, …). |
| `workModes` | string\[] | One or more of 4 work-mode slugs (`hybrid`, `home-office`, `full-office`, `mobile`). |
| `workSchedules` | string\[] | One or more of 3 schedule slugs (`full-time`, `part-time`, `additional`). |
| `positionLevels` | string\[] | One or more of 11 level slugs (`junior`, `senior`, `manager`, …). |

#### Content & Apply

| Field | Type | Description |
|-------|------|-------------|
| `requirements` | string\[] | Pre-split requirement bullets (avg ~10 per posting). |
| `responsibilities` | string\[] | Pre-split responsibility bullets (avg ~7 per posting). |
| `benefits` | string\[] | Pre-split benefit / perk bullets when published. |
| `applyUrl` | string | External ATS form URL (Greenhouse, Traffit, SmartRecruiters, etc.) when the employer wires one through, otherwise the Pracuj.pl-hosted apply page. |
| `applyEmail` | string | Recruiter email when published either in the structured `applying` block or in the free-text body. Often null — most Polish employers route applications through their ATS instead. |
| `contactPhone` | string | Recruiter phone when published in the structured `applying` block. Often null — most postings omit it. |
| `isOneClickApply` | boolean | True when Pracuj.pl supports one-click apply. |
| `isOptionalCv` | boolean | True when CV upload is optional. |
| `isRemoteWorkAllowed` | boolean | True when the listing tags remote work. |
| `isSuperOffer` | boolean | True for Pracuj.pl's "promoted" listings. |

#### Run Metadata

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Which input keyword surfaced this row (null when from `startUrls`). |
| `sourceListUrl` | string | Listing URL the row was discovered on. |

### Tips for Best Results

- **Use Polish keywords for the widest coverage.** Searching `programista` or `inżynier` typically returns 30–40% more rows than the English equivalents on Polish-only roles. Pair English tech terms (`python`, `react`) with Polish job nouns when in doubt.
- **Combine `positionLevels` with `contractTypes` to slice the same query.** Run one pass for `["senior"]` + `["b2b"]` and another for `["mid"]` + `["permanent"]` against the same keyword — that's two clean benchmarking datasets for the same role.
- **Power-user `startUrls` mirrors what you see in your browser.** Build the search on pracuj.pl with every filter you need, copy the URL, and paste it in — the actor honors it exactly. Useful when the guided fields don't cover an edge case.
- **Polish characters in `location` just work.** Type `Łódź`, `Kraków`, `Gdańsk`, or `Wrocław` directly; the actor folds them to the right city slug. Voivodeship names (`mazowieckie`, `małopolskie`) are also accepted.
- **`withSalaryOnly: true` for compensation research.** Roughly two-thirds of Pracuj.pl offers publish a salary — flipping this filter on gives you a clean, structured dataset for benchmarking without post-processing.
- **Start small to verify.** Run with `maxResults: 50` first to confirm the filter combo matches your intent. Pages return ~50 rows each, so the actor will overshoot small caps to keep the last page intact.
- **`publishedWithin: "1"` for daily alerts.** Schedule the actor every morning with the 24-hour window to feed only fresh-today rows into your CRM, Slack, or ATS.

### Pricing

**$1.80 per 1,000 results** — pay-per-result pricing, dramatically cheaper than the headline $3.00–$5.00 / 1k of competing Pracuj.pl scrapers, with full descriptions and contacts included at the flat rate.

| Results | Cost |
|---------|------|
| 100 | $0.18 |
| 1,000 | $1.80 |
| 10,000 | $18.00 |
| 100,000 | $180.00 |

**No compute charges — you only pay per result returned.** A "result" is one unique job posting row. Multi-location postings are collapsed into a single row with every city listed inside, so you never pay for city-duplicate noise. Platform fees (storage, transfer) are additional and depend on your Apify plan.

### 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, refreshed on every run
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access to runs, datasets, and schedules

Schedule the actor to run daily to keep a live feed of Polish job postings flowing into your CRM, BI tool, or candidate database.

### Legal & Ethical Use

This actor is designed for legitimate recruitment, market intelligence, salary benchmarking, and labor-market research. You are responsible for complying with applicable laws (including GDPR and Polish data-protection rules), Pracuj.pl's Terms of Service, and the policies of any system you forward the data into. Do not redistribute recruiter contact information without consent, and do not use the extracted data for spam, harassment, or any illegal purpose. When in doubt, consult your legal team before running large collections.

# Actor input Schema

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

Job keywords to search for (Polish or English work — Pracuj.pl indexes both). Each keyword runs as its own search; rows that match more than one keyword are deduplicated automatically. Leave empty to scrape the unfiltered all-Poland listing.

## `location` (type: `string`):

Where in Poland to search — a city name (e.g. 'Warszawa', 'Kraków', 'Gdańsk') or a voivodeship ('mazowieckie', 'małopolskie'). Polish characters are accepted. Leave empty to search all of Poland.

## `radius` (type: `string`):

Expand the search this many kilometres beyond the selected location. Ignored when Location is empty. Matches Pracuj.pl's radius widget.

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

Power-user input. Paste Pracuj.pl listing URLs (e.g. https://www.pracuj.pl/praca/javascript;kw/warszawa;wp) or individual offer URLs (e.g. https://www.pracuj.pl/praca/...,oferta,1234567). When provided, these override the Search Keywords / Location / Filters fields above.

## `category` (type: `array`):

Restrict to specific job categories. Select multiple to combine. Leave empty for all categories. Mirrors Pracuj.pl's top-level category navigation (35 verified categories).

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

Filter by contract type. Select multiple to combine.

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

Filter by where the work is performed. Select multiple to combine.

## `workSchedule` (type: `array`):

Filter by working-time arrangement. Select multiple to combine.

## `positionLevels` (type: `array`):

Filter by seniority. Select multiple to combine.

## `publishedWithin` (type: `string`):

Only include offers posted within this recency window. 'Any' returns all currently active offers.

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

Skip offers that don't publish a salary range. Useful for compensation research.

## `maxResults` (type: `integer`):

Maximum number of job postings to collect across all searches and URLs. Set to 0 for no cap (an internal safety limit of 100,000 still applies). Results are collected in full pages of ~50 offers, so the final page may overshoot this number by a few rows.

## Actor input object example

```json
{
  "searchQueries": [
    "javascript"
  ],
  "radius": "0",
  "startUrls": [],
  "category": [],
  "contractTypes": [],
  "workModes": [],
  "workSchedule": [],
  "positionLevels": [],
  "publishedWithin": "any",
  "withSalaryOnly": false,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of job postings with the key fields — title, company, salary, primary city, contract type, work mode, and posting URL.

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

Full per-posting fields including description, requirements, responsibilities, benefits, every location the role was published in, recruiter contacts, and timestamps.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "javascript"
    ],
    "radius": "0",
    "startUrls": [],
    "category": [],
    "contractTypes": [],
    "workModes": [],
    "workSchedule": [],
    "positionLevels": [],
    "publishedWithin": "any",
    "withSalaryOnly": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/pracuj-pl-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["javascript"],
    "radius": "0",
    "startUrls": [],
    "category": [],
    "contractTypes": [],
    "workModes": [],
    "workSchedule": [],
    "positionLevels": [],
    "publishedWithin": "any",
    "withSalaryOnly": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/pracuj-pl-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "javascript"
  ],
  "radius": "0",
  "startUrls": [],
  "category": [],
  "contractTypes": [],
  "workModes": [],
  "workSchedule": [],
  "positionLevels": [],
  "publishedWithin": "any",
  "withSalaryOnly": false,
  "maxResults": 100
}' |
apify call solidcode/pracuj-pl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/pracuj-pl-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pracuj.pl Scraper",
        "description": "[💰 $1.8 / 1K]  Extract job listings from Pracuj.pl — Poland's largest job board. Search 60,000+ offers by keyword, location, category, contract type, and work mode. Returns titles, companies, salaries, descriptions, requirements, benefits, and contacts.",
        "version": "1.0",
        "x-build-id": "7tKEAqwIRxKA2GysZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~pracuj-pl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-pracuj-pl-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~pracuj-pl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-pracuj-pl-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~pracuj-pl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-pracuj-pl-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Job keywords to search for (Polish or English work — Pracuj.pl indexes both). Each keyword runs as its own search; rows that match more than one keyword are deduplicated automatically. Leave empty to scrape the unfiltered all-Poland listing.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where in Poland to search — a city name (e.g. 'Warszawa', 'Kraków', 'Gdańsk') or a voivodeship ('mazowieckie', 'małopolskie'). Polish characters are accepted. Leave empty to search all of Poland."
                    },
                    "radius": {
                        "title": "Search Radius",
                        "enum": [
                            "0",
                            "10",
                            "20",
                            "30",
                            "50"
                        ],
                        "type": "string",
                        "description": "Expand the search this many kilometres beyond the selected location. Ignored when Location is empty. Matches Pracuj.pl's radius widget.",
                        "default": "0"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste Pracuj.pl listing URLs (e.g. https://www.pracuj.pl/praca/javascript;kw/warszawa;wp) or individual offer URLs (e.g. https://www.pracuj.pl/praca/...,oferta,1234567). When provided, these override the Search Keywords / Location / Filters fields above.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Job Category",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict to specific job categories. Select multiple to combine. Leave empty for all categories. Mirrors Pracuj.pl's top-level category navigation (35 verified categories).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "administration",
                                "research-development",
                                "banking",
                                "safety-environment",
                                "construction",
                                "call-center",
                                "education",
                                "finance-accounting",
                                "franchise-own-business",
                                "tourism-hospitality",
                                "human-resources",
                                "other",
                                "ecommerce",
                                "engineering",
                                "it-administration",
                                "it-software-development",
                                "supply-chain",
                                "marketing",
                                "media-arts",
                                "real-estate",
                                "customer-service",
                                "physical-labor",
                                "law",
                                "production",
                                "public-relations",
                                "advertising-graphics",
                                "public-sector",
                                "sales",
                                "transport-logistics",
                                "insurance",
                                "purchasing",
                                "quality-control",
                                "health-beauty-recreation",
                                "energy",
                                "consulting"
                            ],
                            "enumTitles": [
                                "Office Administration (Administracja biurowa)",
                                "Research & Development (Badania i rozwój)",
                                "Banking (Bankowość)",
                                "Health & Safety / Environment (BHP / Ochrona środowiska)",
                                "Construction (Budownictwo)",
                                "Call Center",
                                "Education / Training (Edukacja / Szkolenia)",
                                "Finance & Economics (Finanse / Ekonomia)",
                                "Franchise / Own Business (Franczyza / Własny biznes)",
                                "Hospitality / Gastronomy / Tourism (Hotelarstwo / Gastronomia / Turystyka)",
                                "Human Resources (Zasoby ludzkie)",
                                "Other (Inne)",
                                "Internet / E-commerce / New Media",
                                "Engineering (Inżynieria)",
                                "IT — Administration (IT - Administracja)",
                                "IT — Software Development (IT - Rozwój oprogramowania)",
                                "Supply Chain (Łańcuch dostaw)",
                                "Marketing",
                                "Media / Arts / Entertainment (Media / Sztuka / Rozrywka)",
                                "Real Estate (Nieruchomości)",
                                "Customer Service (Obsługa klienta)",
                                "Physical Labor (Praca fizyczna)",
                                "Law (Prawo)",
                                "Production (Produkcja)",
                                "Public Relations",
                                "Advertising / Graphics / Photography (Reklama / Grafika / Kreacja / Fotografia)",
                                "Public Sector (Sektor publiczny)",
                                "Sales (Sprzedaż)",
                                "Transport / Logistics (Transport / Spedycja / Logistyka)",
                                "Insurance (Ubezpieczenia)",
                                "Purchasing (Zakupy)",
                                "Quality Control (Kontrola jakości)",
                                "Health / Beauty / Recreation (Zdrowie / Uroda / Rekreacja)",
                                "Energy (Energetyka)",
                                "Consulting (Doradztwo / Konsulting)"
                            ]
                        },
                        "default": []
                    },
                    "contractTypes": {
                        "title": "Contract Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by contract type. Select multiple to combine.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "permanent",
                                "specific-task",
                                "mandate",
                                "b2b",
                                "substitution",
                                "agency",
                                "temporary",
                                "internship"
                            ],
                            "enumTitles": [
                                "Employment contract (Umowa o pracę)",
                                "Specific-task contract (Umowa o dzieło)",
                                "Mandate contract (Umowa zlecenie)",
                                "B2B contract (Kontrakt B2B)",
                                "Substitution contract (Umowa na zastępstwo)",
                                "Agency contract (Umowa agencyjna)",
                                "Temporary employment (Umowa o pracę tymczasową)",
                                "Internship (Umowa o staż / praktyki)"
                            ]
                        },
                        "default": []
                    },
                    "workModes": {
                        "title": "Work Modes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by where the work is performed. Select multiple to combine.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-office",
                                "hybrid",
                                "home-office",
                                "mobile"
                            ],
                            "enumTitles": [
                                "Office (Praca stacjonarna)",
                                "Hybrid (Praca hybrydowa)",
                                "Remote (Praca zdalna)",
                                "Mobile / field work (Praca mobilna)"
                            ]
                        },
                        "default": []
                    },
                    "workSchedule": {
                        "title": "Work Schedule",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by working-time arrangement. Select multiple to combine.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time",
                                "additional"
                            ],
                            "enumTitles": [
                                "Full-time (Pełny etat)",
                                "Part-time (Część etatu)",
                                "Additional / temporary (Dodatkowa / tymczasowa)"
                            ]
                        },
                        "default": []
                    },
                    "positionLevels": {
                        "title": "Position Levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by seniority. Select multiple to combine.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "intern",
                                "assistant",
                                "junior",
                                "mid",
                                "senior",
                                "expert",
                                "team-leader",
                                "manager",
                                "director",
                                "president",
                                "blue-collar"
                            ],
                            "enumTitles": [
                                "Intern / Trainee (Praktykant / Stażysta)",
                                "Assistant (Asystent)",
                                "Junior",
                                "Mid / Regular (Specjalista)",
                                "Senior",
                                "Expert (Ekspert)",
                                "Team leader (Kierownik / Koordynator)",
                                "Manager (Menedżer)",
                                "Director (Dyrektor)",
                                "President / C-level (Prezes)",
                                "Blue-collar worker (Pracownik fizyczny)"
                            ]
                        },
                        "default": []
                    },
                    "publishedWithin": {
                        "title": "Published Within",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only include offers posted within this recency window. 'Any' returns all currently active offers.",
                        "default": "any"
                    },
                    "withSalaryOnly": {
                        "title": "With Disclosed Salary Only",
                        "type": "boolean",
                        "description": "Skip offers that don't publish a salary range. Useful for compensation research.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of job postings to collect across all searches and URLs. Set to 0 for no cap (an internal safety limit of 100,000 still applies). Results are collected in full pages of ~50 offers, so the final page may overshoot this number by a few rows.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
