# Profesia.sk Jobs Scraper (`solidcode/profesia-sk-scraper`) Actor

\[💰 $1.30 / 1K] Extract job listings from Profesia.sk, Slovakia's largest job board. Search by keyword or URL, filter by region, employment type, salary, remote work and date, and get full descriptions, salary and company details.

- **URL**: https://apify.com/solidcode/profesia-sk-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, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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/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

## Profesia.sk Jobs Scraper

Pull job listings from Profesia.sk — Slovakia's largest job board — at scale, with structured salaries, full descriptions, company profiles, and recruiter contact details on the offers that publish them. Search by keyword, paste URLs, and filter by region, employment type, remote work, salary, and posting date. Built for Slovak and CEE recruiters, HR-tech teams, labor-market analysts, and job-aggregator builders who need clean, structured Profesia.sk data without copy-pasting offers one page at a time.

### Why This Scraper?

- **Every Slovak region in one filter** — narrow results to any of the 8 official regions (Bratislava, Trnava, Trenčín, Nitra, Žilina, Banská Bystrica, Prešov, Košice), plus an Abroad option for jobs located outside Slovakia.
- **Five employment types, natively filtered** — full-time (plný úväzok), part-time (skrátený úväzok), self-employment / trade licence (živnosť), agreement / gig work (dohoda, brigáda), and internship (stáž).
- **On-site, remote, and hybrid split apart** — a dedicated work-location filter isolates fully-remote (práca z domu) roles from hybrid and on-site ones, and with full job details enabled each job also carries a normalized `remoteType` label.
- **Structured salary, not just a text blob** — each disclosed salary is parsed into `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryPeriod`, alongside the original display text. Filter by a monthly or hourly floor in euros.
- **Full descriptions in clean text and original HTML** — return plain text, formatting-preserving HTML, or both in their own fields, so you can index the words and re-render the layout.
- **A full company profile with each job** — with full job details enabled, the employer's Profesia company page, employee-size range, and company description attach to the listing, not just the employer name.
- **Recruiter contact details when published** — with full job details enabled, offers that name a contact expose the contact person and phone plus a direct apply link, ready for outreach.
- **Posting-date windows down to 24 hours** — collect only jobs published in the last 24 hours, 2 days, 7 days, or 30 days for daily monitoring.
- **Up to 5,000 jobs per keyword, auto-deduplicated** — run up to 50 keywords in a single job; duplicates are removed run-wide by job ID.

### Use Cases

**Recruitment & Talent Sourcing**
- Build candidate-facing job boards that mirror Profesia.sk inventory
- Track competitor hiring by company across all 8 regions
- Monitor new postings in your sector every 24 hours
- Assemble recruiter and employer contact lists for outreach

**Labor Market Research**
- Measure salary ranges by role, region, and employment type
- Track demand for specific skills (Java, účtovník, vodič) over time
- Compare full-time versus agreement/gig hiring volumes
- Analyze the share of remote, hybrid, and on-site roles

**Job Aggregators & Data Products**
- Feed a Slovak or wider CEE job aggregator with structured listings
- Enrich existing job databases with salary and company metadata
- Power salary-benchmarking and compensation tools
- Ingest deduplicated feeds keyed on a stable job ID

**HR-Tech & Analytics**
- Benchmark your own openings against live market salaries
- Build dashboards of hiring trends by region and category
- Alert on new roles matching a saved keyword-and-filter set
- Export straight into spreadsheets and BI tools

### Getting Started

#### Quick Keyword Search

The simplest way to start — one keyword and a small result cap:

```json
{
    "searchQueries": ["účtovník"],
    "maxResults": 50
}
````

#### Filtered Search

Combine filters to zero in on exactly the roles you want:

```json
{
    "searchQueries": ["Java developer"],
    "region": "bratislava",
    "employmentType": ["full-time"],
    "remoteWork": "remote",
    "salaryMin": 2000,
    "salaryPeriod": "monthly",
    "maxResults": 200
}
```

#### Advanced — Keywords, URLs, and Full Detail

```json
{
    "searchQueries": ["manažér", "vodič"],
    "startUrls": [
        { "url": "https://www.profesia.sk/praca/kosice/" }
    ],
    "datePosted": "7",
    "maxResults": 1000,
    "includeJobDetails": true,
    "descriptionFormat": "both"
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["účtovník"]` | Job titles or keywords such as "účtovník", "vodič", or "Java developer". Each keyword runs its own search; results are merged and de-duplicated. Up to 50 keywords per run. |
| `startUrls` | array | `[]` | Paste full Profesia.sk URLs directly — filtered search pages, region or category pages, or individual job offers. Any filters baked into a search URL are honored as-is, and paging is automatic. Up to 100 URLs per run. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `region` | string | `Any region` | Limit results to one Slovak region. Use "Abroad" for jobs located outside Slovakia. |
| `employmentType` | array | `[]` | Only collect these employment types: full-time, part-time, self-employment, agreement, or internship. Leave empty to include every type. |
| `remoteWork` | string | `Any` | Filter by where the work is done: on-site, fully remote, or hybrid. |
| `salaryMin` | integer | `null` | Only collect jobs offering at least this salary in euros. Jobs that do not publish a salary are excluded when this is set. |
| `salaryPeriod` | string | `Per month` | Whether the Minimum Salary above is a monthly or an hourly amount. |
| `datePosted` | string | `Any time` | Only show jobs published within this window: last 24 hours, 2 days, 7 days, or 30 days. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum jobs to collect per search keyword. Capped at 5,000 per search. Set to 0 for no per-search limit. The final page is always kept in full, so counts can slightly overshoot. |
| `includeJobDetails` | boolean | `true` | Fetch each job's detail page to fill the full description, `employmentType`, `remoteType`, `positions`, `publishDate`, `education`, benefits, company profile, and contact fields. Turn off for a faster scan that returns only the always-present listing summary (title, company, location, salary, sponsored flag, job link). |
| `descriptionFormat` | string | `Plain text` | How to return the description: plain text, HTML, or both in their own fields. Applies only when Fetch Full Job Details is on. |

### Output

Each job is one row. Here is a representative record with full details enabled:

```json
{
    "title": "Účtovník / Účtovníčka",
    "company": "Tatra banka, a.s.",
    "companyId": "C12345",
    "companyUrl": "https://www.profesia.sk/praca/tatra-banka/C12345",
    "location": "Bratislava",
    "region": "Bratislavský kraj",
    "employmentType": ["full-time"],
    "remoteType": "hybrid",
    "positions": ["Účtovník", "Ekonóm"],
    "salaryText": "Od 1 800 EUR/mesiac",
    "salaryMin": 1800,
    "salaryMax": null,
    "salaryCurrency": "EUR",
    "salaryPeriod": "month",
    "publishDate": "2026-07-14",
    "education": "Vysokoškolské I. stupňa",
    "benefits": "Flexibilný pracovný čas, 5 dní dovolenky navyše, stravné lístky",
    "descriptionSnippet": "Hľadáme skúseného účtovníka do nášho tímu...",
    "description": "Náplň práce:\n- Spracovanie účtovných dokladov\n- Mesačné uzávierky...",
    "descriptionHtml": "<p>Náplň práce:</p><ul><li>Spracovanie účtovných dokladov</li></ul>",
    "companyDescription": "Tatra banka patrí medzi najväčšie banky na Slovensku...",
    "companyEmployeeRange": "1000 a viac zamestnancov",
    "companyLogo": "https://www.profesia.sk/images/logos/12345.png",
    "contactName": "Jana Nováková",
    "contactEmail": null,
    "contactPhone": "+421 2 5919 1000",
    "extractedEmails": [],
    "extractedPhones": [],
    "extractedUrls": [],
    "applyUrl": "https://www.profesia.sk/praca/tatra-banka/O4567890",
    "isSponsored": false,
    "jobUrl": "https://www.profesia.sk/praca/tatra-banka/O4567890",
    "jobId": "4567890",
    "searchQuery": "účtovník",
    "scrapedAt": "2026-07-15T14:30:00Z"
}
```

> **Which fields are always present?** The listing summary — `title`, `company`, `location`, `salaryText` (plus the parsed `salaryMin`/`salaryMax`/`salaryCurrency`/`salaryPeriod`), `isSponsored`, `jobUrl`, and `jobId` — is filled on every row. Everything else, marked with † below (full description, `employmentType`, `remoteType`, `positions`, `publishDate`, `education`, benefits, company profile, and contact fields), is populated only when **Fetch Full Job Details** (`includeJobDetails`, on by default) is enabled.

#### Core Job Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title |
| `company` | string | Employer name |
| `companyId` † | string | Profesia company identifier (e.g. "C12345") |
| `companyUrl` † | string | Employer's Profesia.sk company page |
| `location` | string | Job location as shown on the listing |
| `region` | string | Slovak region — reflects the Region filter you applied (e.g. "Bratislavský kraj"); `null` when no region filter is set |
| `employmentType` † | array | Employment types offered (full-time, part-time, etc.) |
| `remoteType` † | string | Work location: on-site, remote, or hybrid |
| `positions` † | array | Named roles the offer covers |
| `isSponsored` | boolean | Whether the listing is a promoted posting |
| `jobUrl` | string | Direct link to the job offer |
| `jobId` | string | Unique job identifier (used for deduplication) |

† Populated only when Fetch Full Job Details is on.

#### Salary

| Field | Type | Description |
|-------|------|-------------|
| `salaryText` | string | Salary exactly as displayed (e.g. "Od 1 800 EUR/mesiac") |
| `salaryMin` | number | Parsed minimum salary |
| `salaryMax` | number | Parsed maximum salary, when a range is given |
| `salaryCurrency` | string | Currency code (e.g. EUR) |
| `salaryPeriod` | string | Pay period: `month`, `hour`, `year`, or `day` |

#### Description & Requirements

Populated when Fetch Full Job Details is on.

| Field | Type | Description |
|-------|------|-------------|
| `descriptionSnippet` | string | Short summary from the search card |
| `description` | string | Full job description as plain text |
| `descriptionHtml` | string | Full description with original HTML formatting |
| `benefits` | string | Listed employee benefits |
| `education` | string | Required education level, when available |

#### Company

Populated when Fetch Full Job Details is on.

| Field | Type | Description |
|-------|------|-------------|
| `companyDescription` | string | About the employer |
| `companyEmployeeRange` | string | Company size band (e.g. "1000 a viac zamestnancov") |
| `companyLogo` | string | Employer logo URL, when available |

#### Contact & Apply

Populated when Fetch Full Job Details is on.

| Field | Type | Description |
|-------|------|-------------|
| `applyUrl` | string | Application link for the offer |
| `contactPhone` | string | Contact phone number, when the offer names a contact |
| `contactName` | string | Contact person, when the offer names one |
| `contactEmail` | string | Contact email, when the offer publishes one (rarely available — most offers apply via a link) |
| `extractedEmails` | array | Emails found in the description text (rarely available) |
| `extractedPhones` | array | Phone numbers found in the description text (rarely available) |
| `extractedUrls` | array | Links found in the description text (rarely available) |

#### Metadata

| Field | Type | Description |
|-------|------|-------------|
| `publishDate` † | string | Date the job was published (ISO date) |
| `searchQuery` | string | The keyword or source that produced this row |
| `scrapedAt` | string | ISO timestamp of extraction |

† Populated only when Fetch Full Job Details is on.

### Tips for Best Results

- **Leave everything empty for a broad sweep** — with no keywords or filters the scraper collects the newest jobs across all of Slovakia. Add keywords and filters to narrow from there.
- **Sample, then scale** — start with `maxResults` at 50 to confirm the data fits your needs, then raise it (up to 5,000 per keyword) for a full pull.
- **Toggle detail for speed versus depth** — keep Fetch Full Job Details on (the default) for the full description, `employmentType`, `remoteType`, `positions`, `publishDate`, benefits, company profile, and contact details. Turn it off for a faster scan that returns only the always-present listing summary (title, company, location, salary, sponsored flag, and job link).
- **Every selected employment type is covered (power tip)** — when you pick several employment types, the result budget is split fairly across them: each type gets its own share of `maxResults` and every selected type contributes at least its first page, so a common type can't crowd out rarer ones. For a deep pull of one specific type, run it on its own with a higher `maxResults`.
- **Minimum Salary hides salary-less jobs** — setting a salary floor excludes offers that don't publish a salary at all. Leave it empty if you want those postings too.
- **Schedule the 24-hour window** — pair "Posted within: Last 24 hours" with a daily run to capture only fresh roles and avoid re-collecting the same jobs.
- **Reuse browser filters and categories via URLs** — paste a filtered Profesia.sk search or category page into Direct URLs to carry over filters you already set up, including job categories beyond the dropdowns.

### Pricing

**From $1.30 per 1,000 results** — a flat, predictable rate for Slovakia's largest job board. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.16 | $0.15 | $0.14 | $0.13 |
| 1,000 | $1.55 | $1.50 | $1.40 | $1.30 |
| 10,000 | $15.50 | $15.00 | $14.00 | $13.00 |
| 100,000 | $155.00 | $150.00 | $140.00 | $130.00 |

A "result" is any job row in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

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

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

### Legal & Ethical Use

This actor is designed for legitimate labor-market research, recruitment, and analytics. You are responsible for complying with applicable laws and Profesia.sk's Terms of Service. Use collected contact details responsibly and in line with data-protection rules such as GDPR — do not use them for spam, harassment, or any unlawful purpose.

# Actor input Schema

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

Job titles or keywords to search for, such as 'účtovník', 'vodič', 'Java developer' or 'manažér'. Each keyword runs its own search and the results are merged and de-duplicated. Up to 50 keywords per run. Leave empty if you only want to use the direct URLs below.

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

Paste full Profesia.sk URLs directly — search-result pages (for example a search you already filtered in your browser), region or category pages, or individual job-offer pages. Any filters already baked into a search URL are collected exactly as-is, and pagination is handled automatically. Up to 100 URLs per run.

## `region` (type: `string`):

Limit results to one Slovak region. Leave on 'Any region' to search the whole country. Use 'Abroad' for jobs located outside Slovakia.

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

Only collect jobs offering these types of employment. Leave empty to include every type.

## `remoteWork` (type: `string`):

Filter by where the work is done. Leave on 'Any' to include all jobs.

## `salaryMin` (type: `integer`):

Only collect jobs offering at least this salary in euros. Use together with the Salary Period below (monthly or hourly). Leave empty for no minimum. Note: jobs that do not publish a salary are excluded when this filter is set.

## `salaryPeriod` (type: `string`):

Whether the Minimum Salary above is a monthly or an hourly amount. Only used when a minimum salary is set.

## `datePosted` (type: `string`):

Only show jobs published within this time window. Leave on 'Any time' for all jobs.

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

Maximum number of jobs to collect per search keyword. Use 50 for a quick scan or a higher number for deep research. Capped at 5000 per search. Set to 0 (or leave empty) to collect every matching job with no limit up to a 50,000 per-search safety ceiling, which can return a very large number of results for broad keywords. The last page is always kept in full, so the final count can slightly overshoot this number.

## `includeJobDetails` (type: `boolean`):

Fetch each job's detail page to fill the full description, employment type, remote type, positions, publish date, education, benefits, company profile and contact fields. Leave on for the richest data. Turn off for a faster, lighter scan that returns only the always-present listing summary (title, company, location, salary, sponsored flag and job link).

## `descriptionFormat` (type: `string`):

How to return the full job description. 'Plain text' gives clean readable text, 'HTML' preserves the original formatting, 'Both' includes each in its own field. Only applies when Fetch Full Job Details is on.

## Actor input object example

```json
{
  "searchQueries": [
    "účtovník"
  ],
  "startUrls": [],
  "region": "",
  "employmentType": [],
  "remoteWork": "",
  "salaryPeriod": "monthly",
  "datePosted": "",
  "maxResults": 100,
  "includeJobDetails": true,
  "descriptionFormat": "text"
}
```

# Actor output Schema

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

Table of scraped job listings with key fields.

## `detail` (type: `string`):

Complete job records including descriptions, salary, benefits, contact details and company metadata.

# 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": [
        "účtovník"
    ],
    "startUrls": [],
    "region": "",
    "employmentType": [],
    "remoteWork": "",
    "salaryPeriod": "monthly",
    "datePosted": "",
    "maxResults": 100,
    "includeJobDetails": true,
    "descriptionFormat": "text"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/profesia-sk-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": ["účtovník"],
    "startUrls": [],
    "region": "",
    "employmentType": [],
    "remoteWork": "",
    "salaryPeriod": "monthly",
    "datePosted": "",
    "maxResults": 100,
    "includeJobDetails": True,
    "descriptionFormat": "text",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/profesia-sk-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": [
    "účtovník"
  ],
  "startUrls": [],
  "region": "",
  "employmentType": [],
  "remoteWork": "",
  "salaryPeriod": "monthly",
  "datePosted": "",
  "maxResults": 100,
  "includeJobDetails": true,
  "descriptionFormat": "text"
}' |
apify call solidcode/profesia-sk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Profesia.sk Jobs Scraper",
        "description": "[💰 $1.30 / 1K] Extract job listings from Profesia.sk, Slovakia's largest job board. Search by keyword or URL, filter by region, employment type, salary, remote work and date, and get full descriptions, salary and company details.",
        "version": "1.0",
        "x-build-id": "tjFFB4NeuRchePmgI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~profesia-sk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-profesia-sk-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~profesia-sk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-profesia-sk-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~profesia-sk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-profesia-sk-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",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Job titles or keywords to search for, such as 'účtovník', 'vodič', 'Java developer' or 'manažér'. Each keyword runs its own search and the results are merged and de-duplicated. Up to 50 keywords per run. Leave empty if you only want to use the direct URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct URLs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Paste full Profesia.sk URLs directly — search-result pages (for example a search you already filtered in your browser), region or category pages, or individual job-offer pages. Any filters already baked into a search URL are collected exactly as-is, and pagination is handled automatically. Up to 100 URLs per run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "",
                            "bratislava",
                            "trnava",
                            "trencin",
                            "nitra",
                            "zilina",
                            "banska-bystrica",
                            "presov",
                            "kosice",
                            "abroad"
                        ],
                        "type": "string",
                        "description": "Limit results to one Slovak region. Leave on 'Any region' to search the whole country. Use 'Abroad' for jobs located outside Slovakia.",
                        "default": ""
                    },
                    "employmentType": {
                        "title": "Employment Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only collect jobs offering these types of employment. Leave empty to include every type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time",
                                "self-employment",
                                "agreement",
                                "internship"
                            ],
                            "enumTitles": [
                                "Full-time (plný úväzok)",
                                "Part-time (skrátený úväzok)",
                                "Self-employment / trade licence (živnosť)",
                                "Agreement / gig work (na dohodu, brigády)",
                                "Internship (stáž)"
                            ]
                        }
                    },
                    "remoteWork": {
                        "title": "Remote Work",
                        "enum": [
                            "",
                            "onsite",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Filter by where the work is done. Leave on 'Any' to include all jobs.",
                        "default": ""
                    },
                    "salaryMin": {
                        "title": "Minimum Salary (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only collect jobs offering at least this salary in euros. Use together with the Salary Period below (monthly or hourly). Leave empty for no minimum. Note: jobs that do not publish a salary are excluded when this filter is set."
                    },
                    "salaryPeriod": {
                        "title": "Salary Period",
                        "enum": [
                            "monthly",
                            "hourly"
                        ],
                        "type": "string",
                        "description": "Whether the Minimum Salary above is a monthly or an hourly amount. Only used when a minimum salary is set.",
                        "default": "monthly"
                    },
                    "datePosted": {
                        "title": "Posted Within",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only show jobs published within this time window. Leave on 'Any time' for all jobs.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results per Search",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect per search keyword. Use 50 for a quick scan or a higher number for deep research. Capped at 5000 per search. Set to 0 (or leave empty) to collect every matching job with no limit up to a 50,000 per-search safety ceiling, which can return a very large number of results for broad keywords. The last page is always kept in full, so the final count can slightly overshoot this number.",
                        "default": 100
                    },
                    "includeJobDetails": {
                        "title": "Fetch Full Job Details",
                        "type": "boolean",
                        "description": "Fetch each job's detail page to fill the full description, employment type, remote type, positions, publish date, education, benefits, company profile and contact fields. Leave on for the richest data. Turn off for a faster, lighter scan that returns only the always-present listing summary (title, company, location, salary, sponsored flag and job link).",
                        "default": true
                    },
                    "descriptionFormat": {
                        "title": "Description Format",
                        "enum": [
                            "text",
                            "html",
                            "both"
                        ],
                        "type": "string",
                        "description": "How to return the full job description. 'Plain text' gives clean readable text, 'HTML' preserves the original formatting, 'Both' includes each in its own field. Only applies when Fetch Full Job Details is on.",
                        "default": "text"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
