# Jobs.ch & Jobup.ch Scraper - Swiss Jobs, Salaries & Companies (`lukehunter/jobs-ch-scraper`) Actor

Scrape Swiss job ads from jobs.ch and jobup.ch by keyword, location or URL: title, company, location, workload, employment type, salary when published, date. Schedule new-job alerts to Discord, Telegram, Slack or any webhook. No login, no recruiter contact data.

- **URL**: https://apify.com/lukehunter/jobs-ch-scraper.md
- **Developed by:** [Luke Hunter](https://apify.com/lukehunter) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 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.

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

## Jobs.ch & Jobup.ch Scraper - Swiss Jobs, Salaries & Companies

**For recruiters, HR analysts and job seekers who want Swiss job data without copy-pasting.** Give it keywords (and optionally a place such as Zürich or Lausanne), or paste your own jobs.ch / jobup.ch search URLs, and it returns every job ad on the result pages: title, company, location, workload, employment type, the salary when the ad publishes one, and the posting date. It reads the same public search pages a signed-out visitor sees - no login, no session, no recruiter contact data. Turn on **new-job alerts** (`onlyNewSinceLastRun`) and run it on a schedule to get only the jobs you have not seen before.

Pay-per-result: **$0.0015 per job — 1,000 jobs = $1.50.**

### Quick start (1 minute)

1. Open the **Input** tab and enter one or more keywords, e.g. `python`.
2. Pick the **Site**: `jobs.ch` (default) or its French-language sister site `jobup.ch`.
3. Click **Start**. Export the dataset to CSV/Excel/JSON, or pull it through the API shown below.

```json
{
  "searchTerms": ["python"],
  "site": "jobs.ch",
  "maxPagesPerSearch": 1,
  "maxItems": 20
}
```

That prefilled example returns 20 jobs, finishes in well under a minute and costs $0.03.

### How it works

jobs.ch and jobup.ch (both run by JobCloud) embed the full search result in the HTML of every public search page. This Actor:

1. Checks the site's `robots.txt` for the exact path and query of every page it is about to read, and skips that search (saying why in the run's status message) if it is disallowed. It never fetches a job detail page, which jobs.ch's `robots.txt` disallows.
2. Pages through the results - 20 jobs per page - until the site's own last page, your `maxPagesPerSearch`, or your `maxItems`.
3. Turns each ad into one flat dataset row. Anything an ad does not publish is `null`; nothing is guessed or estimated.
4. Reads politely: one honest, self-identifying request about every 3 seconds, no proxies, no cookies, no disguised browsers. A block or challenge page is reported in the run's status message, never worked around, and pages already collected are kept.

### Use cases

- **Swiss job market and salary data**: export every "data engineer", "pflegefachperson" or "comptable" ad with company, canton, workload and - where the ad publishes it - the salary range, for hiring-market research or salary benchmarking.
- **Competitor hiring tracker**: search a company or product name on a schedule to see what Swiss employers are hiring for, how many roles are open and how fast new ones appear.
- **Switzerland job alerts feed**: save a keyword + location (for example `python` in Zürich, or `ingénieur` on jobup.ch for French-speaking Switzerland), schedule the Actor, and pipe only the new jobs into Slack, e-mail or a spreadsheet.

### New-job alerts: get only jobs you have not seen

Turn on `onlyNewSinceLastRun` and put the Actor on a **schedule**: every run after the first delivers (and charges for) only jobs it has not delivered before for that exact search.

```json
{
  "searchTerms": ["python"],
  "location": "Zürich",
  "site": "jobs.ch",
  "onlyNewSinceLastRun": true,
  "maxPagesPerSearch": 2,
  "maxItems": 100
}
```

1. Click **Schedule** on the run page (or create one under **Schedules** in the Apify Console). Daily works well for most searches.
2. **The first scheduled run is a baseline**: it delivers every job currently listed (it is all new to you) and remembers it. You are charged normally for that run.
3. Every later run delivers only jobs not seen before for this exact search.
4. Add a **Webhook** for `ACTOR.RUN.SUCCEEDED` pointing at Apify's Slack/e-mail integration (or a Zapier/Make step) to be told when new jobs arrive.

The status message tells you what happened: `"First run for 1 search: 39 job(s) delivered and remembered; next runs return only new ones."` on the baseline, then `"3 new job(s) since last run across 1 search (36 already seen)."` later. A run that finds nothing new still **succeeds** with an empty dataset - that is the point of the mode.

Each keyword and each search URL is its **own independent watch** (keyed on keyword + location + site, or the exact URL), so several saved searches in one task never mix up their histories. `stateStoreName` only needs changing to isolate or reset a watch.

### Get new Swiss job alerts in Discord, Telegram, Slack, Teams, Google Chat, your phone (ntfy/Pushover) or any app (webhook)

Want a **jobs.ch or jobup.ch job alert** in Discord, Telegram or on your phone instead of checking a dataset? Add one or more destinations in the Actor's **Notifications (optional)** section and each run sends the jobs it delivered. It is a **monitor that notifies you**: it only reads public search pages, and it never applies to a job, contacts a recruiter or logs in to jobs.ch or jobup.ch.

| Channel | Fill in | What you get |
|---|---|---|
| Discord | `discordWebhookUrl` | One card per job, 10 per message |
| Telegram | `telegramBotToken` + `telegramChatId` | Up to 10 jobs per message, one line each |
| Slack | `slackWebhookUrl` | Block Kit message, up to 10 jobs per message |
| Mattermost, Rocket.Chat | `slackCompatibleWebhookUrl` | Slack-style incoming webhook: a Markdown list (these apps do not render Slack Block Kit) |
| Microsoft Teams | `teamsWebhookUrl` | Adaptive Card from a Teams Workflows webhook, up to 10 jobs per card |
| Google Chat | `googleChatWebhookUrl` | Card in a space, up to 10 jobs per message |
| ntfy (phone push, no account) | `ntfyTopic` (optional `ntfyServer`, `ntfyToken`) | A push per job, up to 10, then one "...and N more" |
| Pushover (phone push) | `pushoverUserKey` + `pushoverAppToken` | A push per job, up to 10, then one "...and N more" |
| Any app: Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant | `webhookUrl` | One JSON POST per run with every delivered row |

Fill in as many as you like; each channel works on its own and a failing one never stops the others.

#### Setup, channel by channel

- **Discord (1 minute):** Server Settings → Integrations → Webhooks → New Webhook → pick the channel → **Copy Webhook URL**.
- **Telegram (2 minutes):** chat with **@BotFather**, send `/newbot`, paste the token into `telegramBotToken`. Add the bot to the chat or channel (administrator for a channel; for a chat with yourself press **Start** on the bot). `telegramChatId` is a numeric id (`123456789`, or `-1001234567890` for a group or channel) or a public `@channelusername`.
- **Slack:** at api.slack.com/apps create an app (**From scratch**) → **Incoming Webhooks** → switch it on → **Add New Webhook to Workspace** → pick the channel → copy the `https://hooks.slack.com/services/...` URL.
- **Mattermost or Rocket.Chat:** create an **incoming webhook** in the app and paste its public `https://` URL into `slackCompatibleWebhookUrl`. It must be reachable from the internet: localhost, private IP addresses and `.local` / `.internal` names are rejected.
- **Microsoft Teams:** in the channel open **... → Workflows** → **Post to a channel when a webhook request is received** → finish the wizard and copy the URL (a host ending in `.logic.azure.com` or `.powerplatform.com`). The old "Office 365 connector" webhooks are retired and not supported.
- **Google Chat:** in the space open **Apps & integrations → Webhooks → Add webhook**, name it and copy the `https://chat.googleapis.com/v1/spaces/...` URL (needs a Google Workspace account that allows webhooks).
- **ntfy (free, no account):** install the ntfy app (or open ntfy.sh), subscribe to a topic with a long random name, and put the same name in `ntfyTopic`. Anyone who knows the topic can read it, so make it unguessable. Own server or a protected topic: set `ntfyServer` (public `https://` address) and `ntfyToken`.
- **Pushover:** copy your user key from pushover.net into `pushoverUserKey`, create an application at pushover.net/apps/build and put its API token in `pushoverAppToken`. Pushover itself is a separate paid app after its trial: check their pricing.
- **Any app (webhook):** paste the catch-hook URL from Zapier, Make, n8n, Pipedream, IFTTT or Home Assistant into `webhookUrl`. It must be a public `https://` address.

#### The recipe: a Swiss job alert in five steps

1. Set your search: `searchTerms` with an optional `location` and `site`, or a jobs.ch / jobup.ch search URL with your filters in `startUrls`.
2. Turn on `onlyNewSinceLastRun`.
3. Add your destination(s) from the table above.
4. Run it once. The first run is the baseline and sends the jobs currently listed (up to `maxNotifications`).
5. Create a **Schedule** (daily works for most searches). From then on you only hear about jobs it has not delivered before.

```json
{
  "searchTerms": [
    "python"
  ],
  "location": "Zürich",
  "site": "jobs.ch",
  "onlyNewSinceLastRun": true,
  "maxItems": 100,
  "discordWebhookUrl": "https://discord.com/api/webhooks/<id>/<token>",
  "ntfyTopic": "your-long-random-topic-name",
  "maxNotifications": 25
}
```

#### The generic webhook (`webhookUrl`)

Each run sends **one POST per 100 delivered rows** (so usually one) with this body, followed by whatever your tool does with it:

```json
{
  "source": "apify",
  "actor": "jobs-ch-scraper",
  "runId": "HG7ML7M8z78YcAPEB",
  "count": 2,
  "total": 2,
  "part": 1,
  "parts": 1,
  "items": [
    {
      "...": "the full dataset rows"
    }
  ]
}
```

`count` is the number of rows in this POST, `total` the number delivered in the run, and `part` / `parts` number the POSTs when a run delivers more than 100 rows. `maxNotifications` does not cap the webhook: your tool gets every delivered row. Your endpoint should answer with a 2xx status; redirects are not followed and a failure is reported in the run status, never retried in a loop.

#### What each message contains

Each job is announced as `New job: <title> at <company> — <location>` with the link, the published salary when the ad has one, the workload (for example `80-100%`), employment type, canton, publication date, and the site and search term it came from. Anything the ad does not publish is left out. Discord gets a card per job, Telegram one line per job, Slack Block Kit sections, Teams an Adaptive Card, Google Chat a card, and ntfy/Pushover a push that opens the job. Link previews are off, and titles are escaped so a title can never inject formatting or mentions.

#### What to expect

- **Only delivered jobs are sent.** A run that finds nothing new sends nothing, so there is no "no new jobs" spam. Rows the run could not deliver (for example because your spending limit was reached) are not sent.
- **Without `onlyNewSinceLastRun`, every delivered row is sent**, so a scheduled plain run would repeat the same jobs: use alert mode for alerts (the message then says "New job"; a plain run says "Job").
- **`maxNotifications` (default 25, max 100)** caps how many jobs go to chat and phone channels per run (the webhook is not capped). The rest are still in the dataset and the status message says so. ntfy and Pushover send at most 10 individual pushes, then one "...and N more" summary.
- **Cost: notifications are free.** You pay only the usual price for delivered jobs, exactly as without alerts. There is no extra charge for any channel.
- **Failures never fail the run.** A deleted webhook or an unreachable service leaves the run successful and the dataset complete, and the status message says what happened, for example `Notified: Discord 12, Slack 12, ntfy 10 (+summary). Teams failed (HTTP 404) - check the webhook URL.` The logs show the channel name and HTTP status only, never a URL or token.
- **Your URLs, tokens and ntfy topic are stored as secret inputs.** Anyone holding a webhook URL can post to that channel, so treat it like a password.
- **It is a monitor that notifies you.** It never applies to jobs, contacts recruiters or logs in to jobs.ch or jobup.ch. The messages go only to the destinations you set up.
- **Nothing changes by default.** With no destination set, a run behaves exactly as before and the dataset rows are identical.

### Input

```json
{
  "searchTerms": ["python"],
  "location": "Zürich",
  "site": "jobs.ch",
  "startUrls": [],
  "maxPagesPerSearch": 2,
  "maxItems": 100,
  "onlyNewSinceLastRun": false,
  "stateStoreName": "jobs-ch-scraper-seen-jobs"
}
```

| Field | Type | Default | Description |
|---|---|---:|---|
| `searchTerms` | string\[] | *(none)* | Keywords to search for, e.g. `"python"`. Each is searched on the chosen `site`. Up to 50 per run. |
| `location` | string | *(none)* | Optional place name that narrows every keyword search, e.g. `"Zürich"`. Ignored for `startUrls`. |
| `site` | `"jobs.ch"` | `"jobup.ch"` | `"jobs.ch"` | Which board to search for the keywords. |
| `startUrls` | string\[] | *(none)* | Full jobs.ch or jobup.ch search URLs (any language path), e.g. `https://www.jobs.ch/en/vacancies/?term=python&location=bern`. Filters already in the URL are kept; only pagination is added. Up to 50 per run. At least one of `searchTerms` or `startUrls` is required. |
| `maxPagesPerSearch` | integer | 2 | 1-10. Result pages fetched per keyword or URL; 20 jobs per page. |
| `maxItems` | integer | 100 | 1-5,000. Hard cap on jobs delivered across the whole run - your cost cap. |
| `onlyNewSinceLastRun` | boolean | `false` | New-job alerts mode - see above. |
| `stateStoreName` | string | `jobs-ch-scraper-seen-jobs` | Name of the store that remembers what each alert-mode search has delivered. Letters, numbers and hyphens only. |
| `discordWebhookUrl` | string (secret) | *(none)* | Discord webhook URL. Must look like `https://discord.com/api/webhooks/<id>/<token>`. Empty means no Discord messages. See the alerts section above. |
| `telegramBotToken` | string (secret) | *(none)* | Telegram bot token from @BotFather. Needs `telegramChatId`. |
| `telegramChatId` | string | *(none)* | Telegram chat to post to: a numeric chat id or `@channelusername`. The bot must be added to that chat or channel. Needs `telegramBotToken`. |
| `slackWebhookUrl` | string (secret) | *(none)* | Slack incoming webhook, `https://hooks.slack.com/services/...`. |
| `slackCompatibleWebhookUrl` | string (secret) | *(none)* | Mattermost / Rocket.Chat incoming webhook (public `https://` URL; Markdown list, no Block Kit). |
| `teamsWebhookUrl` | string (secret) | *(none)* | Microsoft Teams Workflows webhook (host ending `.logic.azure.com` or `.powerplatform.com`). |
| `googleChatWebhookUrl` | string (secret) | *(none)* | Google Chat space webhook, `https://chat.googleapis.com/v1/spaces/...`. |
| `ntfyTopic` | string (secret) | *(none)* | ntfy topic name; setting it turns ntfy phone pushes on. Pick a long, unguessable name. |
| `ntfyServer` | string | `https://ntfy.sh` | ntfy server. Only change it for your own public `https://` ntfy server. |
| `ntfyToken` | string (secret) | *(none)* | Optional ntfy access token for a self-hosted server or protected topic. Needs `ntfyTopic`. |
| `pushoverUserKey` | string (secret) | *(none)* | Pushover user key. Needs `pushoverAppToken`. |
| `pushoverAppToken` | string (secret) | *(none)* | Pushover application API token. Needs `pushoverUserKey`. |
| `webhookUrl` | string (secret) | *(none)* | Generic JSON webhook (Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant): every delivered row, 100 per POST. Public `https://` only. |
| `maxNotifications` | integer | 25 | 1–100. Most jobs sent to chat and phone channels per run (the webhook is not capped). Extra jobs are still in the dataset. Only used when a destination is set. |

### Output fields

| Category | Fields |
|---|---|
| Identity | `id`, `url`, `site` |
| Job | `title`, `company`, `location`, `canton`, `publishedAt` |
| Contract | `employmentType`, `workload`, `workloadMin`, `workloadMax` |
| Salary (only when published) | `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` |
| Search context | `searchTerm`, `page`, `position`, `scrapedAt` |

Missing values are returned as `null`. Nothing is invented.

### Output example

A real row from a jobs.ch search for `python` (the ad publishes no salary, so all salary fields are `null`):

```json
{
  "id": "384bbefd-1193-4545-b36f-72cdbd1ffa94",
  "url": "https://www.jobs.ch/en/vacancies/detail/384bbefd-1193-4545-b36f-72cdbd1ffa94/",
  "title": "Senior Fullstack Engineer (C#, Angular, Python) (a)",
  "company": "ERNI Schweiz AG",
  "location": "Zürich",
  "canton": "ZH",
  "employmentType": "Permanent position",
  "workload": "100%",
  "workloadMin": 100,
  "workloadMax": 100,
  "salaryText": null,
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "salaryPeriod": null,
  "publishedAt": "2026-06-25T15:20:58+02:00",
  "site": "jobs.ch",
  "searchTerm": "python",
  "page": 1,
  "position": 1,
  "scrapedAt": "2026-10-03T00:00:00.000Z"
}
```

And a real row whose ad does publish a salary range (jobs.ch, page 2):

```json
{
  "id": "a6a10b48-c5ce-4392-93ba-0aefae34d436",
  "url": "https://www.jobs.ch/en/vacancies/detail/a6a10b48-c5ce-4392-93ba-0aefae34d436/",
  "title": "Embedded Systems Engineer (m/f, 100%)",
  "company": "ROOMZ SA",
  "location": "Bern, Fribourg, Neuchâtel",
  "canton": null,
  "employmentType": "Permanent position",
  "workload": "100%",
  "workloadMin": 100,
  "workloadMax": 100,
  "salaryText": "CHF 80,400 - 114,000 per year",
  "salaryMin": 80400,
  "salaryMax": 114000,
  "salaryCurrency": "CHF",
  "salaryPeriod": "YEAR",
  "publishedAt": "2026-10-01T02:00:12+02:00",
  "site": "jobs.ch",
  "searchTerm": "python",
  "page": 2,
  "position": 17,
  "scrapedAt": "2026-10-03T00:00:00.000Z"
}
```

### Use it as an API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("lukehunter/jobs-ch-scraper").call(
    run_input={
        "searchTerms": ["python", "data engineer"],
        "location": "Zürich",
        "site": "jobs.ch",
        "maxItems": 200,
    }
)

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], "-", job["company"], "-", job["location"], job["salaryText"])
```

### Pricing and cost control

Pay per delivered job.

**$0.0015 per job — 1,000 jobs = $1.50.**

| Jobs delivered | Cost |
|---:|---:|
| 20 | $0.03 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |

There is no charge for starting a run, and no charge for a search that is skipped, blocked or finds nothing. A job that appears on two result pages of the same search is delivered and charged once. `maxItems` gives you a hard upper bound on cost.

Notifications to Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover and webhooks are free: you pay only for delivered jobs, never for messages sent.

### Limitations

- **Search results only.** The Actor reads the search-result pages, not each job's detail page, so it does not collect the full job description, requirements or application route. `url` links to the ad.
- **Salary is rarely published.** Most Swiss ads do not state a salary; in the sample pages used to build this Actor roughly 1 ad in 20 did. Those fields are `null` otherwise. Where a salary is published it is passed on exactly as the advertiser entered it - an occasional ad carries an obviously mis-entered range (for example `90 - 100` per year), and the Actor does not correct it.
- **No recruiter or contact data, by design.** No phone numbers, e-mail addresses or contact persons are collected.
- **Same ad, two sites.** jobs.ch and jobup.ch share many ads, but an ad published on both gets a different `id` on each site. Deduplicate on title + company if you search both.
- **Language.** Ad titles stay in the language the employer wrote them in (German, French, English). `employmentType` is as the site publishes it; it is `null` when the ad has none.
- **Up to 200 jobs per search** (10 pages x 20 jobs). Use narrower keywords or a location for more precise coverage of large result sets.
- **Blocks are reported, not bypassed.** If the site serves a challenge page or an error, the Actor stops that search, says so in the status message, and keeps whatever earlier pages it already collected. You are not charged for a blocked search.
- **Results change.** Ads are added and withdrawn all the time, and the site's relevance ranking decides the order.
- This is an independent tool, not affiliated with, endorsed by or connected to jobs.ch, jobup.ch or JobCloud. You are responsible for using the data in line with the sites' terms and applicable law.

### Use it from your code, Make, Zapier or n8n

Built for automated pipelines: small runs, stable field names, one row per item, and you pay only for rows actually delivered.

**One API call that runs the Actor and returns the data** (replace `$APIFY_TOKEN` with your token from Apify Console → Settings → Integrations):

```bash
curl -s -X POST "https://api.apify.com/v2/acts/lukehunter~jobs-ch-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms": ["python"], "site": "jobs.ch", "maxPagesPerSearch": 1, "maxItems": 20}'
```

**JavaScript** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lukehunter~jobs-ch-scraper').call({
  "searchTerms": [
    "python"
  ],
  "site": "jobs.ch",
  "maxPagesPerSearch": 1,
  "maxItems": 20
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`pip install apify-client`):

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('lukehunter~jobs-ch-scraper').call(run_input={"searchTerms": ["python"], "site": "jobs.ch", "maxPagesPerSearch": 1, "maxItems": 20})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

**Schedules, webhooks and no-code tools:** save your input as a Task, add a Schedule (e.g. hourly or daily), and attach a webhook or one of the Integrations tab's connectors (Make, Zapier, n8n, Google Sheets, Slack) to push each run's results into your own system.

**Only new items each run:** set `"onlyNewSinceLastRun": true` on a scheduled Task and every run after the first delivers, and charges for, only items it hasn't delivered before for that same input. That makes it a ready-made change feed.

**Reliability:** an automated test runs this Actor's parser against the live site every day, and failures are fixed fast.

**Feedback:** an honest rating on the Store page, good or bad, helps others decide if this Actor fits their needs. Missing a field or found a problem? Open an issue on the Actor page.

### FAQ

#### Does this collect recruiter or applicant information?

No. Only what the ad itself shows publicly - title, company, place, workload, employment type, published salary and date.

#### Can I search only one city or canton?

Yes - set `location` (for example `Zürich`), or paste a search URL with the location filter already applied into `startUrls`.

#### Can I search jobup.ch in French?

Set `site` to `jobup.ch` and use French keywords, or paste a `https://www.jobup.ch/fr/emplois/?term=...` URL into `startUrls`.

#### How do I get alerted to new jobs instead of the same ones every time?

Set `onlyNewSinceLastRun: true` and schedule the Actor - see "New-job alerts" above. The first run delivers everything and remembers it; later runs deliver only what is new, and you pay only for those.

#### Why did a run finish with fewer jobs than `maxItems`?

The search simply had fewer results, `maxPagesPerSearch` was reached, or a page was blocked or failed. The run's status message says which.

#### Can I get Swiss job alerts in Discord, Telegram, Slack or on my phone?

Yes. Set `discordWebhookUrl`, `telegramBotToken` + `telegramChatId`, `slackWebhookUrl`, `teamsWebhookUrl` or `googleChatWebhookUrl`, or use `ntfyTopic` (free, no account) or `pushoverUserKey` + `pushoverAppToken` for phone pushes. Mattermost and Rocket.Chat work through `slackCompatibleWebhookUrl`. With `onlyNewSinceLastRun` on and a schedule, each run sends only the jobs it has not delivered before. Setup steps for each are in the alerts section above. Notifications cost nothing extra.

#### Can I get Swiss job alerts by email?

Not natively. There are two routes. (1) Set `webhookUrl` to a Zapier, Make or n8n catch hook and add an email or Gmail step: the webhook delivers every row as JSON, so the email can list the jobs. (2) Apify's own run integrations and run notifications can email you when a run finishes, but they only send a link to the run or dataset, not the jobs themselves. For instant alerts without building anything, Telegram, ntfy or Pushover reach your phone directly.

#### Can I get Swiss job alerts in WhatsApp?

Not natively, and we do not use unofficial WhatsApp APIs, which risk getting your number banned. The official route is the WhatsApp Business Platform (Cloud API) with its own business account, message templates and pricing: point `webhookUrl` at a Zapier, Make or n8n flow that calls it. For free phone alerts use Telegram or ntfy instead.

### More from this publisher

- **[Vinted Scraper & New Listing Alerts](https://apify.com/lukehunter/vinted-scraper)**: resale listings with prices, brands and sizes across any Vinted country.
- **[ATS Job Scraper (Greenhouse Job Alerts)](https://apify.com/lukehunter/greenhouse-job-alerts)**: job postings from company careers pages on Greenhouse, Lever, Workday, Ashby and more, in one schema.
- **[Wellfound Jobs Scraper](https://apify.com/lukehunter/wellfound-jobs-scraper)**: startup jobs from Wellfound with salary ranges, equity and company stage.

# Actor input Schema

## `searchTerms` (type: `array`):

Job keywords to search for, e.g. "python" or "data engineer". Each keyword is searched on the board chosen in "Site" below. Maximum 50 keywords per run.

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

Optional place name to narrow every keyword search, e.g. "Zürich", "Bern" or "Lausanne". Leave empty to search all of Switzerland. Ignored for search URLs, which keep their own filters.

## `site` (type: `string`):

Which job board to search for the keywords above: jobs.ch (German/French/English ads) or its French-language sister site jobup.ch. Search URLs below use their own site.

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

Full jobs.ch or jobup.ch search-result URLs to scrape instead of (or alongside) keywords, e.g. "https://www.jobs.ch/en/vacancies/?term=python\&location=bern". Any filters already in the URL are kept; only pagination is added. Maximum 50 per run.

## `maxPagesPerSearch` (type: `integer`):

How many result pages to fetch for each keyword or search URL, 1-10, default 2. Each page holds up to 20 jobs, so 2 pages is up to 40 jobs per search.

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

Hard cap on the number of jobs delivered across all searches, 1-5000, default 100. You are charged $0.0015 per delivered job, so this is your cost cap.

## `onlyNewSinceLastRun` (type: `boolean`):

Turn this on and run the Actor on a schedule to get only jobs you have not seen before: jobs already delivered on a previous run for the same search (keyword, location and site, or URL) are skipped and never charged again. The first run for a search delivers everything and remembers it. Off by default so a one-off run always returns the full current results.

## `stateStoreName` (type: `string`):

Only used when new-job alerts are on. Name of the key-value store that remembers which jobs each search has already delivered, so it persists across scheduled runs. Leave as the default unless several Actor tasks must not share alert history. Letters, numbers and hyphens only.

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

Post results to a Discord channel. In Discord: Server Settings -> Integrations -> Webhooks -> New Webhook -> choose the channel -> Copy Webhook URL. Looks like https://discord.com/api/webhooks/<id>/<token>. Leave empty to skip Discord.

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

Post results to Telegram. Create a bot by chatting with @BotFather on Telegram (send /newbot) and paste the token it gives you, e.g. 123456789:AA.... Needs "Telegram chat ID" below. Leave empty to skip Telegram.

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

Where the bot should post: a numeric chat id (e.g. 123456789, or -1001234567890 for a group or channel) or a public @channelusername. The bot must be added to that chat or channel first (as an administrator for a channel), and for a private chat you must press Start on the bot. Needs "Telegram bot token" above.

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

Post results to a Slack channel (Block Kit cards, up to 10 per message). Create an incoming webhook at api.slack.com/apps -> Create New App -> Incoming Webhooks -> Add New Webhook to Workspace. Looks like https://hooks.slack.com/services/T000/B000/XXXX. Leave empty to skip Slack.

## `slackCompatibleWebhookUrl` (type: `string`):

Post results to a Mattermost or Rocket.Chat incoming webhook, which accept Slack-style webhook payloads. Must be a public https:// address (no localhost, private IP or .local/.internal hosts). These apps do not render Slack Block Kit, so they get a plain Markdown list. For real Slack use "Slack webhook URL" above. Leave empty to skip.

## `teamsWebhookUrl` (type: `string`):

Post results to a Teams channel as an Adaptive Card. In Teams: channel -> ... -> Workflows -> "Post to a channel when a webhook request is received" -> copy the URL. The host must end in .logic.azure.com or .powerplatform.com. The retired Office 365 connector webhooks are not supported. Leave empty to skip Teams.

## `googleChatWebhookUrl` (type: `string`):

Post results to a Google Chat space. In the space: Apps & integrations -> Webhooks -> Add webhook -> copy the URL. Looks like https://chat.googleapis.com/v1/spaces/<space>/messages?key=...\&token=.... Leave empty to skip Google Chat.

## `ntfyTopic` (type: `string`):

Get a phone push with no account via ntfy (ntfy.sh). Install the ntfy app, subscribe to a topic name, and enter the same name here. Anyone who knows the topic can read it, so pick a long, unguessable name (letters, numbers, - and \_). At most 10 individual pushes per run, then one "...and N more". Leave empty to skip ntfy.

## `ntfyServer` (type: `string`):

Only used with "ntfy topic". Leave as https://ntfy.sh, or enter the public https:// address of your own ntfy server.

## `ntfyToken` (type: `string`):

Only used with "ntfy topic", for a self-hosted server or a reserved topic that needs a login. An access token from ntfy (starts with tk\_). Leave empty for open topics.

## `pushoverUserKey` (type: `string`):

Get a phone push via Pushover. Your user key is shown on the Pushover dashboard (pushover.net). Needs "Pushover app token" below. At most 10 individual pushes per run, then one "...and N more". Leave empty to skip Pushover.

## `pushoverAppToken` (type: `string`):

The API token of a Pushover application you create at pushover.net/apps/build (name it after this Actor). Needs "Pushover user key" above.

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

POST the delivered rows as JSON to any public https:// URL: {source, actor, runId, count, items}. At most 100 rows per POST; every delivered row is sent regardless of the max-notifications cap. Use it to route results to email, a spreadsheet or any app. Localhost, private IP and .local/.internal addresses are rejected. Leave empty to skip.

## `maxNotifications` (type: `integer`):

Caps how many results are sent to chat and phone channels per run (Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover), 1-100, default 25. Extra results are still in the dataset. The generic webhook is not capped. Only used when a destination above is set.

## Actor input object example

```json
{
  "searchTerms": [
    "python"
  ],
  "site": "jobs.ch",
  "maxPagesPerSearch": 1,
  "maxItems": 20,
  "onlyNewSinceLastRun": false,
  "stateStoreName": "jobs-ch-scraper-seen-jobs",
  "ntfyServer": "https://ntfy.sh",
  "maxNotifications": 25
}
```

# Actor output Schema

## `jobs` (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 = {
    "searchTerms": [
        "python"
    ],
    "site": "jobs.ch",
    "maxPagesPerSearch": 1,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukehunter/jobs-ch-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 = {
    "searchTerms": ["python"],
    "site": "jobs.ch",
    "maxPagesPerSearch": 1,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("lukehunter/jobs-ch-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 '{
  "searchTerms": [
    "python"
  ],
  "site": "jobs.ch",
  "maxPagesPerSearch": 1,
  "maxItems": 20
}' |
apify call lukehunter/jobs-ch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lukehunter/jobs-ch-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/s4Swo0McYMRXq6r0n/builds/Wk7VYoxUlXZWKhNGM/openapi.json