# Prace.cz Jobs Scraper (`shahidirfan/prace-cz-jobs-scraper`) Actor

Scrape Czech Republic's leading job portal instantly. Extract job titles, companies, salaries, descriptions & apply links from Prace.cz. Build recruitment databases, conduct salary analysis, monitor job markets & create training datasets. Structured, ETL-ready output.

- **URL**: https://apify.com/shahidirfan/prace-cz-jobs-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Prace.cz Jobs Scraper

Extract current job listings from Prace.cz with clean structured output. Collect offer titles, companies, locations, salary ranges, employment types, posting dates, and full descriptions for hiring research, monitoring, and recruitment workflows.

### Features

- **Search by URL or keyword** — Start from a full Prace.cz search URL or use a keyword for quick collection
- **Location-aware filtering** — Narrow the output by location text when you need city-specific results
- **Automatic pagination** — Continue across result pages until your target count or page limit is reached
- **Rich offer details** — Capture salary data, employment type, validity dates, and description content when available
- **Clean dataset output** — Removes null and empty values so exports stay production-ready

### Use Cases

#### Job Market Research
Track openings by profession and compare how demand changes over time. Build datasets for hiring trends, salary benchmarking, and competitor analysis.

#### Recruitment Intelligence
Monitor matching offers for a role, city, or custom Prace.cz search. Use the structured output to identify active employers and recurring hiring patterns.

#### Lead Generation
Collect employer names, posting links, and role categories for outreach or business development. Export to spreadsheets, CRMs, or internal dashboards.

#### Content Monitoring
Watch job descriptions and compensation ranges for updates. This is useful for labor market newsletters, industry briefings, and niche talent reports.

---

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `url` | String | No | — | Full Prace.cz search URL or a single offer URL to scrape directly. When both `url` and `keyword` are provided, `url` wins |
| `keyword` | String | No | — | Keyword added to Prace.cz search as `q` when `url` is not provided |
| `location` | String | No | — | Extra location text filter applied to collected jobs |
| `results_wanted` | Integer | No | `20` | Maximum number of jobs to save |
| `max_pages` | Integer | No | `5` | Safety limit for how many search result pages to visit |
| `proxyConfiguration` | Object | No | `{"useApifyProxy": false}` | Optional proxy settings for reliable collection |

---

### Output Data

Each dataset item can include:

| Field | Type | Description |
|-------|------|-------------|
| `title` | String | Job title |
| `url` | String | Job detail URL |
| `source_site` | String | Source hostname such as `prace.cz` or `jobs.cz` |
| `search_url` | String | Search page URL where the offer was collected |
| `job_id` | String | Source job identifier |
| `job_uuid` | String | Source job UUID |
| `company` | String | Employer name |
| `company_hint` | String | Employer name extracted from listing data |
| `company_identifier` | String | Source company or advertiser identifier when available |
| `location` | String | Combined location text |
| `address_locality` | String | City or locality |
| `street_address` | String | Street address when available |
| `postal_code` | String | Postal code |
| `address_country` | String | Country code |
| `employment_type` | Array | Employment type values from structured offer data |
| `salary_currency` | String | Salary currency |
| `salary_min` | Number | Minimum salary value |
| `salary_max` | Number | Maximum salary value |
| `salary_unit` | String | Salary period such as `MONTH` |
| `date_posted` | String | Posted date |
| `valid_through` | String | Offer validity date |
| `primary_category` | String | Main listing category |
| `categories` | Array | Category labels |
| `professions` | Array | Profession labels |
| `description_html` | String | Raw description HTML |
| `description_text` | String | Plain-text description |
| `requires_external_form` | Boolean | Indicates whether the offer uses an external application form |

---

### Usage Examples

#### Keyword Search

Collect software-related openings from the default search results:

```json
{
    "keyword": "programator",
    "results_wanted": 20,
    "max_pages": 5
}
````

#### Search URL Collection

Use a fully prepared Prace.cz search URL:

```json
{
    "url": "https://www.prace.cz/hledat/?q=programator&page=2",
    "results_wanted": 30,
    "max_pages": 4
}
```

#### Location Narrowing

Collect only jobs whose resolved location matches your filter text:

```json
{
    "keyword": "skladnik",
    "location": "Brno",
    "results_wanted": 15,
    "max_pages": 8
}
```

#### Single Offer URL

Scrape one offer directly:

```json
{
    "url": "https://www.prace.cz/nabidka/c8d127f6-144b-40ac-b07d-c4cf65bb0a07/"
}
```

***

### Sample Output

```json
{
    "title": "Operátor výroby – až 37 000,- Kč Brno-Slatina R1",
    "url": "https://www.prace.cz/nabidka/c8d127f6-144b-40ac-b07d-c4cf65bb0a07/",
    "source_site": "prace.cz",
    "search_url": "https://www.prace.cz/hledat/?q=programator",
    "job_id": "2001289682",
    "job_uuid": "c8d127f6-144b-40ac-b07d-c4cf65bb0a07",
    "company": "Diallogue Česká republika a.s.",
    "company_identifier": "snp3cq",
    "location": "Brno, CZE",
    "address_locality": "Brno",
    "street_address": "Švédské valy",
    "postal_code": "62700",
    "address_country": "CZE",
    "employment_type": [
        "FULL_TIME",
        "EMPLOYEE"
    ],
    "salary_currency": "CZK",
    "salary_min": 37000,
    "salary_max": 38000,
    "salary_unit": "MONTH",
    "date_posted": "2026-06-19T04:55:02.871737+02:00",
    "valid_through": "2026-07-19T23:59:59+02:00",
    "categories": [
        "Kvalita a kontrola jakosti",
        "Strojírenství",
        "Výroba a průmysl"
    ],
    "professions": [
        "Kvalitář",
        "Dělník",
        "Operátor výroby",
        "Montážní technik"
    ],
    "description_text": "Co od Vás očekáváme: Základní vzdělání... "
}
```

***

### Tips for Best Results

#### Use a Search URL for Exact Site Filters

- Build a search on Prace.cz first when you need the site’s own filter logic
- Paste that final result URL into `url`
- Keep `max_pages` modest while testing

#### Use `location` for Narrow Output

- The `location` input is best used as a narrowing filter on collected jobs
- Use city names such as `Brno`, `Praha`, or `Ostrava`
- Combine it with a keyword to reduce unnecessary pages

#### Start Small

- Use `results_wanted: 20` for fast validation
- Increase the result count only after confirming the query works
- Raise `max_pages` only when you need deeper pagination

#### Proxy Configuration

- Add proxy settings if you plan long or repeated runs
- Residential proxies can help when collecting at larger scale
- Small test runs usually work without a proxy

***

### Integrations

Connect your data with:

- **Google Sheets** — Review offers and salary data in a spreadsheet
- **Airtable** — Build a searchable recruiting database
- **Make** — Trigger automation when new jobs match a keyword
- **Zapier** — Forward listings into CRMs or messaging tools
- **Webhooks** — Send fresh results into your own pipeline

#### Export Formats

- **JSON** — For apps and automation
- **CSV** — For spreadsheet work
- **Excel** — For reporting
- **XML** — For custom integrations

***

### Frequently Asked Questions

#### Can I use a full Prace.cz search URL?

Yes. If you already have a working search URL, put it into `url` and the actor will continue from there.

#### Can I scrape a single offer page?

Yes. A direct offer URL returns one enriched record when the page exposes the structured offer data.

#### How does the location filter work?

The actor keeps jobs whose resolved location text matches your `location` value. This is useful when you want city-specific output from broader searches.

#### Will the actor remove empty values?

Yes. Null, undefined, and empty-string fields are removed before data is stored.

#### What happens if a detail page has less information?

The actor still saves the available fields from the listing and includes enriched details only when the source provides them.

#### How many pages can I collect?

Use `max_pages` to cap pagination. Increase it for broader searches, or keep it low for fast test runs.

***

### Support

For issues or feature requests, contact support through the Apify Console.

#### Resources

- [Apify Documentation](https://docs.apify.com/)
- [API Reference](https://docs.apify.com/api/v2)
- [Schedules](https://docs.apify.com/platform/schedules)

***

### Legal Notice

This actor is designed for legitimate data collection purposes. Users are responsible for ensuring compliance with website terms of service and applicable laws. Use the collected data responsibly.

# Actor input Schema

## `url` (type: `string`):

Optional full Prace.cz search URL or a direct offer URL. This takes priority when both URL and keyword are filled.

## `keyword` (type: `string`):

Search keyword used when URL is not provided.

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

Keep only jobs whose resolved location matches this text.

## `results_wanted` (type: `integer`):

Maximum number of jobs to collect.

## `max_pages` (type: `integer`):

Safety limit for the number of search pages to visit.

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

Optional Apify Proxy configuration.

## Actor input object example

```json
{
  "keyword": "programator",
  "results_wanted": 20,
  "max_pages": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keyword": "programator",
    "results_wanted": 20,
    "max_pages": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/prace-cz-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keyword": "programator",
    "results_wanted": 20,
    "max_pages": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/prace-cz-jobs-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 '{
  "keyword": "programator",
  "results_wanted": 20,
  "max_pages": 5
}' |
apify call shahidirfan/prace-cz-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Prace.cz Jobs Scraper",
        "description": "Scrape Czech Republic's leading job portal instantly. Extract job titles, companies, salaries, descriptions & apply links from Prace.cz. Build recruitment databases, conduct salary analysis, monitor job markets & create training datasets. Structured, ETL-ready output.",
        "version": "0.0",
        "x-build-id": "4ThU4O4W0lhlI6E3o"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahidirfan~prace-cz-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahidirfan-prace-cz-jobs-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/shahidirfan~prace-cz-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-shahidirfan-prace-cz-jobs-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/shahidirfan~prace-cz-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-shahidirfan-prace-cz-jobs-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": {
                    "url": {
                        "title": "Search or offer URL",
                        "type": "string",
                        "description": "Optional full Prace.cz search URL or a direct offer URL. This takes priority when both URL and keyword are filled."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Search keyword used when URL is not provided."
                    },
                    "location": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Keep only jobs whose resolved location matches this text."
                    },
                    "results_wanted": {
                        "title": "Results wanted",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect.",
                        "default": 20
                    },
                    "max_pages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Safety limit for the number of search pages to visit.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
