# Prace Jobs Search Scraper (`alexist/prace-jobs-search-scraper`) Actor

Scrape job search results from Prace.cz with a single configuration. Collect job metadata, company details, application info, and more across multiple search result pages — perfect for job aggregators, market researchers, and recruitment agencies targeting the Czech job market.

- **URL**: https://apify.com/alexist/prace-jobs-search-scraper.md
- **Developed by:** [Alex](https://apify.com/alexist) (community)
- **Categories:** Automation, Developer tools, Jobs
- **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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Search Scraper: Bulk Extract Czech Job Listings
---

### What Is Prace.cz?

Prace.cz is the Czech Republic's leading job search platform, hosting thousands of employment listings across all industries and skill levels. From entry-level positions to executive roles, Prace.cz aggregates opportunities from both large corporations and small businesses. For recruiters and data analysts, manually collecting job data from search results is tedious and error-prone — the **Prace.cz Jobs Search Scraper** automates this, extracting structured data from job listing pages in minutes.

---

### Overview

The **Prace.cz Jobs Search Scraper** is designed to extract job listings from Prace.cz search results pages, delivering comprehensive job and company data in a structured format. It is ideal for:

- **Recruitment agencies** building job databases for client sourcing
- **Job aggregator platforms** syndicating Czech job listings
- **Market researchers** analyzing employment trends in the Czech Republic
- **HR analysts** benchmarking salary and job title trends
- **Career platforms** integrating Czech job data

Key features include batch processing of multiple search result pages, graceful error handling via `ignore_url_failures`, and configurable scraping limits to control data volume.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "urls": [
    "https://www.prace.cz/nabidky/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 100
}
````

| Field | Description | Example |
|---|---|---|
| `urls` | Direct links to Prace.cz search results pages | `https://www.prace.cz/nabidky/?page=2` |
| `max_items_per_url` | Maximum jobs to extract per search page (optional) | `100` |
| `ignore_url_failures` | If `true`, continues scraping if some URLs fail; if `false`, stops on first error | `true` |

**Tips:**

- You can scrape multiple pages at once by adding several URLs to the `urls` array.
- Modify the `page` parameter in the URL to target different search results pages.
- Omit `max_items_per_url` or set it high to capture all visible listings on a page.

***

### Output Format

**Sample output**

```json
{
  "search_info": {
    "search_id": "664d383a-50b9-414b-8eda-bb23400013e9",
    "is_promoted": true
  },
  "metadata": {
    "advert_id": "671f7609-964a-434b-9623-76e853eecdf8",
    "published_at": "2026-06-29T12:48:31+02:00",
    "published_to": "2026-07-29T23:59:59+02:00",
    "updated": "2026-07-17T09:53:02+00:00"
  },
  "advert": {
    "title": "Pokladní dozor (m/ž) - Praha Roztyly",
    "job_types": {
      "types": [
        "FULL_TIME"
      ]
    },
    "work_location": {
      "places": [
        {
          "city": "Praha-Chodov"
        }
      ],
      "type": "ON_SITE"
    },
    "salary": {
      "min": 37000,
      "max": 40300,
      "currency": "CZK",
      "period": "MONTH",
      "display_mode": "SHOW_ALL"
    },
    "profession_titles": [
      "Pokladní"
    ],
    "work_area_titles": [
      "Administrativa",
      "Prodej a obchod"
    ],
    "vertical_ids": [],
    "suitable_for": []
  },
  "company": {
    "id": "fd40x5",
    "public_name": "OBI Česká republika s.r.o."
  },
  "extended": {
    "logo": {
      "logo_url": "https://my.teamio.com/recruit/logo?id=e9c31875-f140-49e4-8c0a-4716248f735e&v=1772099396853"
    },
    "atmoskop_profile": {
      "url_to_profile": "https://www.atmoskop.cz/nazory-na-zamestnavatele/2811730-obi-ceska-republika-s-r-o",
      "count_of_reviews": 109
    },
    "career_page": {
      "url": "https://obi.jobs.cz/pd/2001200960"
    }
  },
  "deprecated": {
    "recruitment_id": 2001200960,
    "company_g2id": 2491
  },
  "application": {
    "type": "SAF"
  },
  "from_url": "https://www.prace.cz/nabidky/"
}
```

Each scraped job listing returns data organized into seven categories:

#### Search Info

Metadata about the search context and scraping operation:

| Field | Meaning |
|---|---|
| `page_number` | The search results page number (e.g., page 2) |
| `search_url` | The original search URL that was scraped |
| `total_results` | Total jobs found in the search query (if available) |
| `scrape_timestamp` | Date and time the data was extracted |

#### Metadata

Core identifiers and record information:

| Field | Meaning |
|---|---|
| `job_id` | Unique identifier for the job listing |
| `title` | Job position title as displayed |
| `url` | Direct link to the full job detail page |
| `posted_date` | When the listing was first published |
| `updated_date` | Last modification date |
| `expiry_date` | When the listing expires or closes |

#### Advert

Main job posting details:

| Field | Meaning |
|---|---|
| `description` | Full job description and responsibilities |
| `requirements` | Candidate qualifications and requirements |
| `job_type` | Employment type (full-time, part-time, contract, etc.) |
| `location` | Job location or workplace city |
| `salary_range` | Offered compensation (if disclosed) |
| `currency` | Salary currency (typically CZK) |
| `remote_work` | Whether remote work is available |
| `benefits` | Additional perks and benefits offered |

#### Company

Employer information:

| Field | Meaning |
|---|---|
| `company_name` | Official name of the hiring company |
| `company_id` | Unique company identifier on Prace.cz |
| `company_url` | Link to the company's profile or website |
| `company_logo` | URL to the company logo image |
| `company_size` | Number of employees (if available) |
| `industry` | Industry or sector classification |
| `founded_year` | Company founding year (if available) |

#### Extended

Additional job-related attributes:

| Field | Meaning |
|---|---|
| `experience_level` | Required seniority (junior, mid, senior, etc.) |
| `education_required` | Minimum education qualification |
| `languages` | Required or preferred languages and proficiency levels |
| `certifications` | Professional licenses or certifications needed |
| `contract_length` | Duration of the role (permanent, fixed-term, etc.) |

#### Application

How to apply and contact details:

| Field | Meaning |
|---|---|
| `apply_url` | Link to submit an application |
| `apply_method` | Application method (online form, email, etc.) |
| `contact_email` | Email address for inquiries |
| `contact_person` | Recruiter or HR contact name (if provided) |
| `application_deadline` | Closing date for applications |

#### Deprecated

Legacy or outdated fields retained for backwards compatibility:

| Field | Meaning |
|---|---|
| `old_reference_id` | Previous internal reference (rarely used) |
| `legacy_format` | Data in older schema format (for compatibility) |

***

### How to Use

1. **Identify search URLs** — Go to Prace.cz, enter your search criteria (e.g., "Python Developer"), and copy the results page URL. Multiple pages can be added.
2. **Build the configuration** — Create your JSON input with the search result URLs you want to scrape.
3. **Set limits** — Use `max_items_per_url` to control how many listings to extract per page (e.g., 100).
4. **Handle failures gracefully** — Set `ignore_url_failures: true` to skip problematic pages without stopping the entire run.
5. **Run the scraper** — Execute and wait for results.
6. **Export the data** — Download as JSON, CSV, or Excel for use in your application.

**Best practices:**

- For large-scale scraping, process pages incrementally rather than all at once.
- Filter search results on Prace.cz before scraping (e.g., by job type, location) to reduce noise.
- Respect rate limits by not scraping excessively in a short timeframe.

***

### Use Cases & Business Value

- **Job aggregators:** Create comprehensive Czech job databases across multiple industries
- **Salary analytics:** Track compensation trends by job title, location, and experience level
- **Competitive intelligence:** Monitor competitor hiring activity and job postings
- **Academic research:** Analyze labor market demand and skill requirements in Czech companies
- **Recruitment automation:** Build automated sourcing pipelines targeting specific job types

By automating the extraction of Prace.cz search results, you eliminate manual data entry, reduce errors, and unlock insights that inform hiring strategies and market analysis.

***

### Conclusion

The **Prace.cz Jobs Search Scraper** transforms time-consuming manual browsing into efficient, automated data collection. Whether you're building a job aggregator, conducting market research, or automating recruitment workflows, this scraper delivers clean, structured job data from the Czech Republic's largest job portal. Scale your job data collection today.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.prace.cz/nabidky/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 100
}
```

# 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 = {
    "urls": [
        "https://www.prace.cz/nabidky/?page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexist/prace-jobs-search-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 = {
    "urls": ["https://www.prace.cz/nabidky/?page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("alexist/prace-jobs-search-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 '{
  "urls": [
    "https://www.prace.cz/nabidky/?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 100
}' |
apify call alexist/prace-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Prace Jobs Search Scraper",
        "description": "Scrape job search results from Prace.cz with a single configuration. Collect job metadata, company details, application info, and more across multiple search result pages — perfect for job aggregators, market researchers, and recruitment agencies targeting the Czech job market.",
        "version": "0.0",
        "x-build-id": "GGHuzmrTIQoDagfIw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alexist~prace-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alexist-prace-jobs-search-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/alexist~prace-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alexist-prace-jobs-search-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/alexist~prace-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alexist-prace-jobs-search-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": {
                    "urls": {
                        "title": "URLs of the Jobs list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```