# Kariera.sk Scraper ($0.57/1K): Slovak Jobs & Salaries (`tsutseisoftware/kariera-sk-scraper`) Actor

Scrape Kariera.sk, the Slovak job board of Zoznam.sk: jobs with salary, employer, region and district. Tells employers' own offers from those taken over from labour offices. Track new and removed jobs. Unofficial.

- **URL**: https://apify.com/tsutseisoftware/kariera-sk-scraper.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.54 / 1,000 jobs

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kariera.sk Scraper: Slovak Jobs, Salaries & Employers

Get job listings from **Kariera.sk** (kariera.zoznam.sk), the job board of Zoznam.sk and one of the most visited in **Slovakia** (about 8 400 open jobs), as clean structured data. For each job you get the title, the employer, the places of work with their **region (kraj) and district (okres)**, the **salary as numbers** with monthly and hourly equivalents, the date of the ad and, at no extra cost, the **source of the offer**: placed on Kariera.sk by the employer, or taken over from the **Slovak labour offices** (about 85 % of the website). Optionally the actor opens each job page and adds the **description** (with e-mails and phone numbers removed), employment type, categories, benefits, requirements, education, start date, application deadline and the company's description and address.

Search by **keywords**, **region, district or town**, **category**, **employment type**, **salary** and **age of the ad**: these are the website's own filters, so filtered-out jobs cost nothing. Or set any search on the website and paste its address.

Built for **watching the Slovak job market**: schedule it daily in monitoring mode and you get, and pay for, only jobs that are new or changed, plus, if you want, the jobs that **disappeared** since the last run, **reposts** told apart from new positions, and a **job alert** in Slack, Discord, Telegram, WhatsApp or your webhook. Every run also saves a free **market summary** (salary median and quartiles by region, offer source and category, top employers).

> **Česky / Slovensky:** Scraper pracovních nabídek z **Kariera.sk** (kariera.zoznam.sk): mzda převedená na čísla, zaměstnavatel, kraj a okres, rozlišení vlastních inzerátů od nabídek převzatých z úřadů práce, volitelně popis, typ úvazku, benefity a požadavky. Filtry webu (klíčová slova, lokalita, kategorie, úvazek, plat), monitoring nových a odstraněných nabídek, upozornění do Slacku nebo Telegramu. Výstup do Excelu, CSV nebo JSON. Podporu poskytujeme i česky.

### Why use this Kariera.sk scraper?

- 🏷️ **You know whose offer it is, without opening the job.** About 85 % of the jobs on Kariera.sk are taken over from the Slovak labour offices (sluzbyzamestnanosti.gov.sk); the rest are placed by employers and recruitment agencies. The field `sourcePortal` (`kariera` or `urady-prace`) is filled for every job at no extra cost, and **Offer source** keeps only one kind. With details you also get the address of the original labour-office offer, its **SK ISCO-08 code**, the number of vacancies and its end date.
- 🔎 **The website's own filters as inputs:** keywords, 8 regions, 72 districts, 114 towns and 27 countries, 40 categories, employment type (full-time, part-time, self-employed, temporary job, internship), salary from, posted in the last N days, without recruitment agencies, suitable for graduates. Any other filter of the website (education, languages) works through a pasted search URL.
- 💰 **Salaries you can compute with:** `salaryMin`, `salaryMax`, currency and period, plus monthly and hourly equivalents. 98 % of jobs show a salary. An hourly wage typed into the monthly field ("od 6 EUR/Mesiac") is kept as shown but not converted.
- 🗺️ **Region and district for 98 % of jobs,** at no extra cost. Jobs abroad get their country.
- 📬 **Monitoring:** a daily list of new and changed jobs (`changeType`), optionally removed and reappeared jobs (`removedAt`, `daysOnline`), unchanged jobs, and reposts: the same job seen before under another number (`isRepost`).
- 🔔 **Job alerts** to Slack, Discord, Telegram, WhatsApp or any webhook, without setting up an integration.
- 🔒 **Privacy first.** The contact block of a job page (contact person, phone) is not read unless you turn **Add contact details** on. E-mails and phone numbers inside descriptions are replaced with `[e-mail removed]` and `[phone removed]`. Employers who are private persons (sole traders, about 10 % of the employers of labour-office offers) are never named.
- ⚡ **Fast and light:** 1 000 jobs take about a minute. No proxy needed. You pay per saved job, **with no extra platform costs**.

### What data can you get?

| Field | Example |
|---|---|
| Title, employer, employer profile and logo | Kuchár - Nemocnica Topoľčany (m/ž), Penta Hospitals SK, a. s. |
| Offer source | `kariera` (placed by the employer) or `urady-prace` (taken over from the labour offices) |
| Places, region, district, country | Okres Malacky, Malacky, Stupava → Bratislavský kraj, Malacky, Slovensko |
| Salary | "2000 - 10000 EUR/Mesiac" → 2 000 – 10 000 EUR per month; "7,50 EUR/hod" → 7.5 per hour (monthly 1 200) |
| Date and labels | postedAt 2026-11-11, isPromoted (Top), tags ("Zabezpečené ubytovanie") |
| With **Add description and details** | description (plain text, Markdown or HTML), employment type, categories and positions, benefits, requirements, salary details, education, languages, driving licence, start date, application deadline, suitable for (graduates, disabled), views and replies, the company's description, industry and address |
| Labour-office offers, with details | address of the original offer, SK ISCO-08 code and occupation, number of vacancies, end date |
| With **Monitoring** | changeType `new`, `updated`, `removed`, `reappeared`, `unchanged`; changedFields, firstSeenAt, lastSeenAt, removedAt, daysOnline, isRepost, repostOf |
| With **Add contact details** | contactNames, contactPhones, contactEmails (personal data, see below) |

Open the results as a table in Apify Console (views **Overview**, **Salaries**, **Details**, **Employers**, **Labour office offers**, **Monitoring**, **Removed jobs**) or export them to **Excel, CSV, JSON or XML**.

### How to scrape Kariera.sk

1. Open the actor and fill in **Search queries** (e.g. `vodič`), **Locations** (e.g. `Bratislavský kraj`) or **Categories**, or leave them empty to get the newest jobs of the whole website.
2. Set **Max jobs** (you pay per saved job) and turn on **Add description and details** if you need descriptions, employment types and company data.
3. Click **Start**. When the run finishes, open the **Output** tab or download the dataset.

### Use cases

#### Drivers' jobs in the Bratislava and Trnava regions with a salary of at least 1 200 EUR

```json
{
  "searchQueries": ["vodič"],
  "locations": ["Bratislavský kraj", "Trnavský kraj"],
  "employmentTypes": ["fullTime"],
  "minSalary": 1200,
  "maxItems": 200
}
```

All four are filters of the website, so the run reads only matching jobs.

#### New jobs placed by employers, every morning in Slack

```json
{
  "offerSource": "kariera",
  "postedWithinDays": 2,
  "onlyNewOrChanged": true,
  "monitoringKey": "own-offers",
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxItems": 0
}
```

Schedule it daily. The first run returns all matching jobs, the next ones only new and changed jobs. Offers taken over from the labour offices are left out.

#### IT jobs with full descriptions for skills analysis

```json
{
  "categories": ["informatika-software", "informatika-sprava-systemov"],
  "includeDetails": true,
  "descriptionFormat": "markdown",
  "maxItems": 300
}
```

#### Labour-office vacancies of one district with their SK ISCO codes

```json
{
  "locations": ["okres Nitra"],
  "offerSource": "urady-prace",
  "includeDetails": true,
  "maxItems": 500
}
```

#### Which jobs were filled or withdrawn this week

```json
{
  "locations": ["Košický kraj"],
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "kosice",
  "maxItems": 0
}
```

#### A search set up on the website

```json
{
  "startUrls": [{ "url": "https://kariera.zoznam.sk/pracovne-ponuky/bratislavsky-kraj/hlavny-pracovny-pomer" }],
  "maxItems": 100
}
```

Set any filters on Kariera.sk (also education and languages), copy the address of the results and paste it. Job URLs (`https://kariera.zoznam.sk/pracovna-ponuka/<number>/<name>`) work too; each is read with all details.

#### Website filters (applied by Kariera.sk)

**Search queries**, **Locations**, **Categories**, **Employment type**, **Salary from**, **Posted in the last N days**, **Without recruitment agencies** and **Only jobs suitable for graduates** are the website's own search filters, so filtered-out jobs cost nothing. Each search query is one search; several locations or categories in one search mean "any of them". A location the website does not know stops the run with an explanation: the website itself would silently search the whole country.

#### Filters (applied by the actor, you don't pay for filtered-out jobs)

**Offer source**, **Only jobs with a salary**, **Title must contain / must not contain**, **Employer** and **Exclude employers** need no job pages (no **Job page read** charge). **Title or description must contain** needs the job pages. The website cannot filter by these, so the actor may read more pages than the saved jobs explain; those are charged as **Extra page** (see Pricing). The newest jobs of the website are mostly employers' own offers and the older ones labour-office offers, so **Offer source** over the whole website reads many pages: combine it with a location, a category or keywords.

#### Monitoring mode explained

With **Monitoring: only new or changed jobs** the actor remembers the jobs of the previous run with the same **Monitoring key** (left empty, the key is derived from the searches of the run, so every watched search keeps its own state) and saves only jobs that are new (`changeType: new`) or whose title, employer, salary or places changed (`updated`, with `changedFields`). The date of the ad is not a change: promoted ads get a new date every day. With **Monitoring: include removed jobs** you also get jobs that are no longer in the search (`removed`, with `lastSeenAt`, `removedAt` and `daysOnline`) and jobs that came back (`reappeared`). Removed jobs are checked only when the run read every search completely. With **Add description and details**, job pages are opened only for the new and changed jobs.

- **Monitoring: include unchanged jobs** also returns the jobs that did not change (`changeType: unchanged`, search page data, no job page read again). They are saved rows, so they are charged like any other job.
- **Monitoring: skip reposted jobs**: employers publish the same ad again under a new number. A new job that is the same job seen in an earlier run under another number is marked `isRepost: true` with `repostOf`; with this option it is not returned and not charged.

#### Notifications (job alerts)

Fill in a Slack or Discord webhook, a Telegram bot token with a chat ID, a WhatsApp access token with your business phone number ID and the recipient's number, or any HTTPS webhook URL (Zapier, Make, n8n, your server), and after each run the actor sends the saved jobs there: title, employer, place, salary and link, at most **Max jobs per message** of them (default 10) and "…and N more", with links to the run and the dataset. With monitoring that is a daily alert with the new, changed and removed jobs; nothing is sent on a day without changes (unless you turn **Only when something was saved** off). Descriptions and contacts are never sent, the webhook addresses and tokens are stored encrypted, and a channel that fails never fails the run. A run that delivered its notification is charged once as **Notification**, whatever the number of channels. For WhatsApp (with a message template, so that it arrives at any time) see [WhatsApp notifications: setup](#whatsapp-notifications-setup). For e-mail or Teams point the webhook URL at an automation tool and let it forward the message.

#### Description formats and compact output

**Description format** picks the format of `description` (plain text, Markdown or clean HTML). **Description formats (several at once)** adds `descriptionText`, `descriptionMarkdown` and `descriptionHtml` next to it for the same price. **Description length limit** shortens it. **Compact output** keeps the core fields of every row and **Leave out empty fields** drops null and empty ones: smaller rows for AI agents and MCP clients, at the same price.

#### Contact details (optional, personal data)

Many job pages of employers' own offers end with a contact block: a contact person, sometimes a phone number or an e-mail address (in a sample of 60 own offers, 54 had at least one of them; labour-office offers have none). By default the actor does not read it. With **Add contact details** you get `contactNames`, `contactPhones` and `contactEmails`: what the contact block shows, and phone numbers and e-mail addresses written in the description. They are **personal data**: you are responsible for a lawful basis for using them (GDPR) and for the anti-spam rules of your country. They are never returned for an employer who is a private person, never sent in notifications and never logged; descriptions keep their e-mails and phone numbers removed. A saved job with at least one contact is charged as **Contact details**.

#### Market summary (SUMMARY)

Every run saves a free JSON record `SUMMARY` in the key-value store: how many jobs the website reported and how many matched, the **share of offers taken over from the labour offices**, the share with a salary, the **median and quartiles of the monthly salary in EUR** overall, by region, by offer source and (with details) by category (groups of at least 5 jobs), the top 20 employers, employment types and regions. In monitoring mode it covers unchanged jobs too.

### How much does it cost to scrape Kariera.sk?

This actor uses pay-per-event pricing (see the **Pricing** tab for the current prices). You pay only for these events; **platform usage (compute, storage, data transfer) is included**.

| Event | Price per 1 000 | Bronze | Silver | Gold and higher |
|---|---|---|---|---|
| Job saved in the dataset | **$0.57** | $0.56 | $0.55 | $0.54 |
| Job page read ("Add description and details", job URLs) | + $0.20 | + $0.20 | + $0.20 | + $0.20 |
| Contact details (per 1 000 saved jobs that have a contact) | + $0.30 | + $0.30 | + $0.30 | + $0.30 |
| Fast mode | + $0.01 | + $0.01 | + $0.01 | + $0.01 |
| Monitoring: listing page checked (per 1 000 pages = 30 000 jobs) | $0.20 | $0.20 | $0.20 | $0.20 |
| Extra page (per 1 000 pages read beyond the saved jobs) | $0.20 | $0.20 | $0.20 | $0.20 |
| Notification (per run that sent one) | $0.001 | $0.001 | $0.001 | $0.001 |
| Actor start (per run) | $0.004 | $0.004 | $0.004 | $0.004 |

1 000 jobs from the search pages cost **$0.57**, with descriptions and details **$0.77**. The whole website (about 8 400 jobs) costs about $4.80, with details $6.50. A daily monitoring run of a search with 600 jobs (20 pages) that finds 10 new ones costs about $0.014 (start, 20 checked pages and 10 jobs). Filtered-out jobs, unchanged jobs in monitoring mode and the market summary are free.

**Extra page** ($0.0002 a page) is charged at the end of the run for pages read beyond what the saved jobs need: a search without jobs, a job URL that is no longer active, an **Offer source**, **Employer**, **Title** or **description** filter that reads many pages for a few jobs (the website cannot filter by them), and a job that was removed while the run was reading it. A plain search pays nothing more. Pages paid as monitoring pages and pages the website rejected are never extra pages. Your maximum cost per run covers them too.

### Input example

```json
{
  "searchQueries": ["vodič"],
  "maxItems": 20,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Output example

A job from a search page with **Add description and details** (shortened):

```json
{
  "id": "kariera-sk:1574869",
  "source": "kariera.sk",
  "url": "https://kariera.zoznam.sk/pracovna-ponuka/1574869/kuchar-nemocnica-topolcany-m-z-",
  "jobId": "1574869",
  "title": "Kuchár - Nemocnica Topoľčany (m/ž)",
  "company": "Penta Hospitals SK, a. s.",
  "companyUrl": "https://kariera.zoznam.sk/ponuky-spolocnosti/penta-hospitals-sk-a-s-",
  "companyLogoUrl": "https://kariera.zoznam.sk/images/logos/29739_logo_alt.svg",
  "companyDescription": "Sme integrovaným poskytovateľom zdravotnej starostlivosti novej generácie. …",
  "companyIndustry": null,
  "companyAddress": "Penta Hospitals SK, a. s., Einsteinova 23-25, 85101 Bratislava 5, Slovenská republika",
  "sourcePortal": "kariera",
  "sourcePortalUrl": null,
  "location": "Topoľčany",
  "locations": ["Topoľčany"],
  "region": "Nitriansky kraj",
  "district": "Topoľčany",
  "regions": ["Nitriansky kraj"],
  "country": "Slovensko",
  "salaryText": "od 1031 EUR/Mesiac",
  "salaryMin": 1031,
  "salaryMax": null,
  "salaryCurrency": "EUR",
  "salaryPeriod": "month",
  "salaryMonthlyMin": 1031,
  "salaryMonthlyMax": null,
  "salaryHourlyMin": 6.44,
  "salaryHourlyMax": null,
  "salaryNote": "Od 1031, - Eur. Výška mzdy závisí od profilu kandidáta",
  "employmentType": ["fullTime"],
  "categories": [],
  "positions": ["Kuchár"],
  "tags": [],
  "suitableFor": ["graduates"],
  "educationRequired": "stredoškolské bez maturity",
  "languagesRequired": null,
  "drivingLicence": null,
  "startDate": "dohodou (ASAP)",
  "applicationDeadline": "2026-11-30",
  "iscoCode": null,
  "iscoName": null,
  "vacancies": null,
  "postedAt": "2026-11-11",
  "isPromoted": true,
  "viewCount": null,
  "replyCount": null,
  "benefits": "Budúcim kolegom ponúkame:\n\n- dôkladné zaškolenie v tíme …",
  "requirements": "- vzdelanie v odbore Kuchár\n- Bezúhonnosť …",
  "description": "Do nášho tímu prijmeme kuchára na výkon prác:\n\n- pripravovanie všetkých ponúkaných jedál …",
  "detailScraped": true,
  "changeType": null,
  "changedFields": null,
  "firstSeenAt": null,
  "lastSeenAt": null,
  "removedAt": null,
  "daysOnline": null,
  "isRepost": null,
  "repostOf": null,
  "sourceUrl": "https://kariera.zoznam.sk/pracovne-ponuky",
  "scrapedAt": "2026-11-11T10:00:00Z"
}
```

Without details the fields of the job page are null or empty lists and `detailScraped` is false. A labour-office offer with details has `sourcePortal: "urady-prace"`, `sourcePortalUrl: "https://sluzbyzamestnanosti.gov.sk/pracovne-ponuky/…"`, `iscoCode: "5142002"`, `iscoName: "Pedikér"`, `vacancies: 2` and `companyUrl: null`.

### Good to know

- **Offer source** is known for every job without opening its page. On 9 job pages we checked it matched the page's own note "Pracovná ponuka je prevzatá zo stránky Úradov práce" every time; with details the job page decides.
- **Salary** is what the website shows: mostly a monthly amount or range in EUR, sometimes an hourly wage, rarely CZK for jobs in the Czech Republic. "od X" has only `salaryMin`. Some employers enter an hourly wage as a monthly salary ("od 6 EUR/Mesiac"): such amounts stay in `salaryMin`/`salaryMax` but get no period and no equivalents (about 3 % of jobs). For job URLs the salary comes from the job page, with the period inferred from the amount.
- **Hourly and monthly equivalents** use standard full-time hours. Nothing is converted between currencies or between gross and net.
- **Employment type, categories and positions** are on job pages only, so they are empty without **Add description and details** (the website's **Employment type** filter works without them).
- **Region and district** come from the places of work, at no extra cost. The first place decides `region` and `district`; `regions` has the regions of all places.
- **The date** (`postedAt`) is the date the website shows and sorts by; promoted ("Top") ads get a new date every day.
- **Employers who are private persons** (sole traders advertising through the labour offices under their own name) are hidden automatically: `company`, the profile, logo, address and contacts are null, and their name is replaced with `[name removed]` in the title and texts. In doubt, privacy wins: in a live sample of 256 employers of labour-office offers (November 2026) 27 were hidden, 26 of them sole traders and one a name of unclear kind; no employer with a profile on Kariera.sk was hidden.
- **Free text may still name a person** (e.g. "kontaktujte p. Novákovú"): e-mails and phone numbers are removed from descriptions, names inside the text are not.
- **Job pages with an employer's own layout** (Lidl, Penta Hospitals…) are read too; headings the employer wrote ("Tvoj profil", "Naše benefity") stay in the description.
- A search returns the newest jobs first. The same job found by two searches of one run is saved once.
- No proxy needed. A page Kariera.sk rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. It never solves challenges. A job URL whose page is rejected is looked up in the website's search; when the search shows the same job, it is returned with the listing data (the status message says how many).

### For AI agents and API users

Apify's own MCP server (mcp.apify.com) exposes every actor in the Store as a tool, so an AI agent can call this actor without a separate connector; **Compact output** and **Leave out empty fields** keep the rows small for a model's context.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/kariera-sk-scraper").call(run_input={
    "searchQueries": ["programátor"], "locations": ["Bratislavský kraj"], "offerSource": "kariera", "maxItems": 100,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["region"], job["salaryMonthlyMin"], job["sourcePortal"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["sourcePortals"], summary["salary"]["monthly"])
```

### Troubleshooting

- **"Kariera.sk has no place called …"**: write the place as the website lists it: a region (`Bratislavský kraj`), a district or bigger town (`Košice`, `okres Malacky`, `Žilina`) or a country (`Rakúsko`). Villages are not in the website's list; use their district.
- **"does not know '…' and would return a wider search"**: a URL you pasted has a filter the website does not recognise; open it in your browser and copy the address again.
- **"rejecting requests"**: try again later, or set **Proxy** to Apify Proxy.
- **Many extra pages with "Offer source"**: the filter is the actor's own; narrow the search with a location, a category or keywords.
- **A job URL "could not be read (a job that is no longer active …)"**: the job is no longer active on the website.
- **"could not be read (Kariera.sk did not answer or showed an unexpected page)"**: this says nothing about the URL; try again later.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### More Czech job scrapers

The same output format for the other Czech job sources (many jobs are published on several of them):

- [Czech Jobs Aggregator](https://apify.com/tsutseisoftware/czech-jobs-aggregator): all these Czech job boards in one run: duplicates merged, one output format, monitoring
- [Jobs.cz Scraper](https://apify.com/tsutseisoftware/jobs-cz-scraper): Czech jobs with salary, region, requirements, monitoring and optional ARES company data
- [Prace.cz Scraper](https://apify.com/tsutseisoftware/prace-cz-scraper): Czech jobs with salary, region, monitoring and optional ARES company data
- [Úřad práce Scraper](https://apify.com/tsutseisoftware/urad-prace-scraper): all Czech Labour Office vacancies (MPSV open data) with salary, profession, shifts and jobs for foreigners
- [Pracezarohem.cz Scraper](https://apify.com/tsutseisoftware/pracezarohem-scraper): jobs near a town (GPS distance search) from all big Czech job sources, with the portal of every ad
- [JenPráce.cz Scraper](https://apify.com/tsutseisoftware/jenprace-scraper): Czech jobs and side jobs with salary, own ads told apart from Labour Office vacancies
- [StartupJobs.cz Scraper](https://apify.com/tsutseisoftware/startupjobs-scraper): IT and startup jobs with salary, technologies, seniority, remote work, company profiles and an IT market overview
- [Profesia.sk & .cz Scraper](https://apify.com/tsutseisoftware/profesia-scraper): Slovak and Czech jobs from Profesia with salary, region and monitoring
- [Fajn-brigady.cz & INwork.cz Scraper](https://apify.com/tsutseisoftware/fajn-brigady-scraper): Czech temporary and part-time jobs from two websites: hourly wage, town, start date, monitoring
- [GastroJobs.cz Scraper](https://apify.com/tsutseisoftware/gastrojobs-scraper): Czech hotel, restaurant and catering jobs: salary, type of venue, employer company ID, monitoring

Need jobs straight from company career sites in any country? [Career Site Job Search](https://apify.com/tsutseisoftware/ats-jobs-scraper) searches Greenhouse, Workday, Lever, Ashby and SmartRecruiters job boards without a company list, including the jobs that just closed.

### FAQ

#### Is it legal to scrape Kariera.sk?

It reads only publicly available data, without logging in, at most 30 requests per minute (120 in the fast mode), slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. By default it returns no contact persons, removes e-mails and phone numbers from descriptions and hides employer names that look like a private person's name. The website's terms of use may restrict automated access; you are responsible for how you use the data, especially for anything covered by GDPR or database rights. This actor is not affiliated with or endorsed by Kariera.sk or Zoznam, s.r.o.

#### Why is the employer empty for some jobs?

When the employer's name looks like a private person's name, the name is personal data, so it is not returned (see "Good to know").

#### Do I need a proxy?

No proxy needed; none is set by default.

#### Can I get only the jobs that are not copied from the labour offices?

Yes: set **Offer source** to "Only offers placed on Kariera.sk by employers". It needs no job pages, so there is no **Job page read** charge.

#### Can I use it through the API, in Make, Zapier or n8n?

Yes. Every Apify actor can be started through the API and the Apify integrations; the built-in notifications need no integration at all.

#### Why do I get fewer jobs than the website shows?

The website's number in the heading is the size of the whole search. The actor stops at **Max jobs** and at **Max pages per search**, saves a job found by two searches once, and leaves out the jobs your filters reject; the status message of the run says how many and why.

***

Also known as a Kariera.sk API, kariera.zoznam.sk scraper, Slovak jobs scraper, "pracovné ponuky Kariera.sk", "voľné pracovné miesta" or "ponuky práce Slovensko".

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/kariera-sk-scraper/changelog.md

# Actor input Schema

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

Keywords the website searches in job titles and descriptions, e.g. "vodič", "operátor výroby", "účtovník", "Lidl". Each query is a separate search, combined with the locations, categories and website filters below. Empty = all jobs.

## `locations` (type: `array`):

Places as Kariera.sk lists them: a region ("Bratislavský kraj"), a district or town ("Košice", "okres Malacky", "Žilina", "Stupava") or a country for jobs abroad ("Rakúsko", "Česká republika"). Diacritics are optional. Several places are one search (jobs in any of them). A name that is both a district and its town means the district; add "mesto" for the town alone ("Malacky mesto"). A place the website does not know stops the run with an explanation instead of searching the whole country.

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

Kariera.sk categories (jobs in any of them). Empty = all categories.

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

Search URLs from Kariera.sk, e.g. https://kariera.zoznam.sk/pracovne-ponuky/bratislavsky-kraj/hlavny-pracovny-pomer (set any filters on the website, also education or languages, and paste the address of the results), or job URLs (https://kariera.zoznam.sk/pracovna-ponuka/<number>/<name>; a job URL is read with all details and charged as a job with "Job page read"). A search is always read from its first page. The filters of the "Website filters" section are not added to pasted URLs.

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

Maximum number of jobs saved. You pay per saved job. 0 = no limit.

## `maxPages` (type: `integer`):

Read at most this many pages (30 jobs each) of every search. 0 = no limit.

## `includeDetails` (type: `boolean`):

Open each job page to add the description (e-mails and phone numbers removed), employment type, categories and positions, benefits, requirements, education, start date, application deadline, the company's description and address and, for offers taken over from the labour offices, the SK ISCO code, number of vacancies and the address of the original offer. Extra charge "Job page read" (see the Pricing tab) per saved job whose page was read. Off: data of the search pages only (title, employer, places, salary, date, offer source).

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

With "Add description and details": the format of the description.

## `descriptionFormats` (type: `array`):

With "Add description and details": also return the description in each of these formats, as the fields descriptionText, descriptionMarkdown and descriptionHtml (next to "description"). E-mails and phone numbers are removed in every format. No extra charge.

## `descriptionMaxLength` (type: `integer`):

With "Add description and details": shorten the description to about this many characters (e.g. 300 for a snippet). 0 = full text.

## `includeContacts` (type: `boolean`):

With the job pages: add the contact person, phone numbers and e-mail addresses the job page shows (fields contactNames, contactPhones, contactEmails). Off by default. These are personal data: you are responsible for a lawful basis for using them (GDPR) and for the anti-spam rules. Never returned for an employer who is a private person; descriptions keep their e-mails and phone numbers removed. Turns "Add description and details" on. Charged as "Contact details" per saved job that has at least one contact (see the Pricing tab).

## `employmentTypes` (type: `array`):

Only jobs offering one of these employment types.

## `minSalary` (type: `integer`):

The website's "Plat od" filter, e.g. 1500: only jobs whose salary reaches this amount; jobs without a salary are left out.

## `postedWithinDays` (type: `integer`):

Only jobs published or refreshed in the last N days. The website filters by 1, 2, 7, 31, 183 or 365 days; for other values it gives the next longer period and the actor checks the date. 0 = any time.

## `excludeAgencies` (type: `boolean`):

The website's "Bez pracovných agentúr" filter: leave out jobs advertised by recruitment agencies.

## `onlyForGraduates` (type: `boolean`):

The website's "Vhodné pre absolventov" filter.

## `offerSource` (type: `string`):

Most jobs on Kariera.sk (about 85 %) are taken over from the Slovak labour offices (sluzbyzamestnanosti.gov.sk); the rest are placed by employers and agencies. This filter needs no job pages (no "Job page read" charge). The website has no such filter: search pages read beyond the saved jobs are charged as "Extra page".

## `onlyWithSalary` (type: `boolean`):

Skip jobs that show no salary (about 5 % of the jobs).

## `titleKeywords` (type: `array`):

Keep only jobs whose title contains at least one of these texts (case and diacritics don't matter).

## `excludeKeywords` (type: `array`):

Skip jobs whose title contains any of these texts.

## `descriptionKeywords` (type: `array`):

Keep only jobs with at least one of these words in the title or the description, matched at the start of a word without case and diacritics ("vodič" finds "vodiča", "program" finds "programátor"); a word of up to 3 letters must be the whole word ("ADR" finds neither "nadriadený" nor "adresa"). Needs the job pages, so it turns "Add description and details" on; pages of jobs without the words are charged as "Extra page".

## `companies` (type: `array`):

Keep only jobs of employers whose name contains one of these texts, e.g. "Lidl", "Grafton".

## `excludeCompanies` (type: `array`):

Skip jobs of employers whose name contains any of these texts.

## `onlyNewOrChanged` (type: `boolean`):

Return only jobs that are new or whose title, employer, salary or places changed since the previous run with the same Monitoring key. Unchanged jobs are free; every search page read in this mode is charged as "Monitoring: listing page checked" (see the Pricing tab; one page = up to 30 jobs).

## `monitoringKey` (type: `string`):

Name of the saved state. Use a different key for each watched search (e.g. "vodic-bratislava"). Empty = a key derived from the searches and job URLs of the run, so different searches never share a state (changing a search then starts a new one). The value is stored encrypted.

## `includeRemovedJobs` (type: `boolean`):

With "Monitoring: only new or changed jobs": also return jobs of the previous run that are no longer in the search, as rows with changeType "removed" (and "reappeared" when they come back). Checked only when the run reads every search completely (limits, unread pages or rejected requests skip the check, and the status message says why). Removed rows are charged like any other job.

## `includeUnchanged` (type: `boolean`):

With "Monitoring: only new or changed jobs": also return the jobs that did not change, as rows with changeType "unchanged" (search page data; their job pages are not read again). They are saved rows, so each is charged like any other job; without this option unchanged jobs are free.

## `skipReposts` (type: `boolean`):

With "Monitoring: only new or changed jobs": do not return a new job when the same job was seen in an earlier run under another ID (the employer published the ad again). Skipped jobs are not charged. Off = such jobs are returned with isRepost true and repostOf.

## `compact` (type: `boolean`):

Keep only the core fields of every row: id, title, employer, offer source, location, region, district, salary with the monthly equivalent, employment type, categories, posting date, link (and the monitoring fields).

## `excludeEmptyFields` (type: `boolean`):

Drop fields that are null or an empty list from every row (id, source, url, jobId, title and scrapedAt always stay).

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...). Stored encrypted.

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `telegramBotToken` (type: `string`):

Token of your Telegram bot (from @BotFather). Used with "Telegram chat ID". Stored encrypted.

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n, your server): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many jobs are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no job (e.g. a monitoring run without new jobs).

## `fastMode` (type: `boolean`):

Fast mode reads up to about 4× faster and drops back to the normal speed for the rest of the run at the first sign of load. It never changes IP address to get around a limit. Useful with "Add description and details"; runs without job pages are fast anyway. Charged as "Fast mode" per saved job (see the Pricing tab).

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

Kariera.sk answers without a proxy. Turn a proxy on only if the website starts rejecting requests.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searchQueries": [
    "vodič"
  ],
  "maxItems": 20,
  "maxPages": 0,
  "includeDetails": false,
  "descriptionFormat": "text",
  "descriptionMaxLength": 0,
  "includeContacts": false,
  "excludeAgencies": false,
  "onlyForGraduates": false,
  "offerSource": "all",
  "onlyWithSalary": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "includeUnchanged": false,
  "skipReposts": false,
  "compact": false,
  "excludeEmptyFields": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "fastMode": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `summary` (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 = {
    "searchQueries": [
        "vodič"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/kariera-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": ["vodič"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/kariera-sk-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "vodič"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/kariera-sk-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tsutseisoftware/kariera-sk-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/UBCG1PGL88IMtN8Jd/builds/pYLbphGnLTXk1Ked0/openapi.json
