# Jobup.ch Jobs Scraper (`jobsapi/jobup-ch-jobs-search-scraper`) Actor

Collect complete public Jobup.ch JobPosting records through bounded search, single, and multiple modes with verified detail enrichment.

- **URL**: https://apify.com/jobsapi/jobup-ch-jobs-search-scraper.md
- **Developed by:** [Jobs API](https://apify.com/jobsapi) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 jobup.ch job records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does the Jobup.ch Jobs Search Scraper do?

**Collect complete public [Jobup.ch](https://www.jobup.ch/) job listings and detail records** with an Apify Actor built for Swiss vacancies.

Inventory position: **163**. This Actor collects public Jobup.ch listing pages locally or on Apify Cloud and enriches each candidate from its exact public detail page. It uses the official `JobPosting` JSON-LD published by the site and never invents missing fields.

### Why use this Actor?

Use it to collect structured public Swiss job data for vacancy research, job-market analysis, or a recurring public-listing monitor. Search mode discovers roles from listings; single and multiple modes enrich known detail URLs. Runs are bounded and sequential, and the Actor preserves request receipts and diagnostics in the key-value store so fewer-than-requested results are explainable. Apify Console, API calls, and scheduled runs can use the same input contract.

### Quick start

1. Open the [Jobup.ch Jobs Search Scraper](https://apify.com/jobsapi/jobup-ch-jobs-search-scraper) in Apify Console.
2. Choose **Search** mode and paste the example input below, changing the search term if needed.
3. Run with a small `maxPages` and `maxItems` first. Review complete records in the default dataset; run status and request diagnostics are in the default key-value store.

Each emitted row is verified against the exact public detail URL. Search rows that cannot be completed or verified are not filled with guesses.

### Modes

Search mode discovers public jobs from `/en/jobs/` (or the equivalent supported locale route), adds the `term` query when `searchQuery` is supplied, and follows a bounded number of pages. Single mode accepts one exact public detail URL. Multiple mode accepts several exact public detail URLs. Detail enrichment is enabled by default because a listing card does not contain the full description or all public fields.

Example search input:

```json
{
  "mode": "search",
  "startUrls": ["https://www.jobup.ch/en/jobs/"],
  "searchQuery": "software engineer",
  "maxPages": 1,
  "maxItems": 5
}
```

For one known role, use single mode:

```json
{
  "mode": "single",
  "jobUrl": "https://www.jobup.ch/en/jobs/detail/5c1870d5-e5d6-418f-9914-eff03a571489/"
}
```

For a bounded group of known roles, use multiple mode:

```json
{
  "mode": "multiple",
  "jobUrls": [
    "https://www.jobup.ch/en/jobs/detail/5c1870d5-e5d6-418f-9914-eff03a571489/",
    "https://www.jobup.ch/en/jobs/detail/478b69aa-12a1-4ecb-a8f5-bf5367bf0110/"
  ],
  "maxItems": 2
}
```

Direct modes use `jobUrls`, or the `jobUrl` convenience alias. Outputs can include the complete description and sections, employer overview, organization URL/logo, employment details, work hours, start date, openings, application contact metadata, location/address, applicant-location requirements, salary fields when published, categories, benefits, skills, dates, listing evidence, and normalized data-quality coverage. Request receipts and diagnostics are stored in KVS, not copied into job rows. Optional publisher fields are omitted when Jobup does not publish them.

The Actor uses ordinary direct HTTPS requests, response-size and request-budget limits, and processes requests sequentially with configurable spacing. It retries only transient HTTP 408, 425, and 5xx responses. It does not use a proxy, fingerprint spoofing, CAPTCHA solving, login, private endpoints, or access-control bypasses. Blocked or incomplete pages remain KVS diagnostics and are never represented by fabricated job rows.

Diagnostic records retain the requested run mode and a normalized human-readable error. RUN_SUMMARY, REQUEST_RECEIPTS, and RUN_METADATA provide stable named cloud outputs in addition to compatibility keys.

### Input controls

Use `startUrls` for public listing pages, `jobUrl` for one exact detail page, or `jobUrls` for a bounded list. Select a mode that matches the supplied URLs; the Actor validates mode and URL combinations before making requests. `page` and `maxPages` bound listing discovery. `maxItems` caps complete output records. `timeoutSecs`, `maxRetries`, `requestDelayMs`, `maxRequests`, and `maxResponseBytes` bound resource use. Unknown fields and temporary fixture or context controls are rejected.

| Input | Default | Allowed range / behavior |
| --- | --- | --- |
| `mode` | inferred (`search`, `single`, or `multiple`) | Search requires listing URLs; single requires exactly one detail URL; multiple requires one or more detail URLs. |
| `startUrls` | `https://www.jobup.ch/en/jobs/` | Up to 10 public HTTPS Jobup.ch listing URLs; search mode only. |
| `jobUrl` / `jobUrls` | — | One URL for single mode, or up to 100 for multiple mode. Multiple mode examines at most `maxItems × 2` supplied URLs and emits at most `maxItems` complete records. |
| `searchQuery` / `term` | — | Up to 150 characters. `term` is an alias; `searchQuery` takes precedence if both are supplied. |
| `page` | `1` | Integer from 1 to 1,000; starting page for each listing URL. |
| `maxPages` | `1` | Integer from 1 to 10, applied per listing URL. |
| `maxItems` | `5` (single mode is always one) | Integer from 1 to 100; maximum complete records to emit. |
| `timeoutSecs` | `20` | Integer from 5 to 120 seconds per request. |
| `maxRetries` | `1` | Integer from 0 to 3; only transient HTTP 408, 425, and 5xx responses are retryable. Access denials and generic transport failures are not retried. |
| `requestDelayMs` | `500` | Integer from 250 to 5,000 milliseconds between sequential requests. |
| `maxRequests` | `50` | Integer from 1 to 200; hard cap shared by listing and detail requests. |
| `maxResponseBytes` | `10,000,000` | Integer from 100,000 to 50,000,000 bytes per response. Oversized responses are not parsed as complete pages. |

All supplied URLs must be exact public Jobup.ch HTTPS listing or detail URLs. Each search result needs a detail request, so the request budget and item cap can result in fewer records than visible listing cards. Values that Jobup only adds during client-side rendering and does not include in the Actor's ordinary HTML response are not emitted.

### Output fields

The default dataset contains only complete records verified against their exact public detail pages. Available fields include:

| Field group | Examples |
| --- | --- |
| Job identity | `jobId`, `title`, `jobUrl`, `canonicalUrl`, `identifier` |
| Employer | `companyName`, `companyUrl`, `companyLogo`, `employerOverview`, `industry` |
| Role details | `description`, `responsibilities`, `qualifications`, `niceToHave`, `benefits`, `skills` |
| Work arrangement | `employmentType`, `workHours`, `workloadPercentage`, `jobLocationType`, `locations`, `languageRequirements` |
| Compensation and dates | `salary`, `salaryMin`, `salaryMax`, `salaryCurrency`, `datePosted`, `validThrough` |
| Verification and quality | `detailVerified`, `fieldCoverage`, `dataQuality` |

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Access-barrier evidence, request receipts, run diagnostics, and summaries are kept in the key-value store.

#### Example dataset record

This shortened excerpt comes from a locally generated and detail-verified Jobup record. Arrays are abbreviated for readability; the full dataset row also includes description provenance, field coverage, and other source-published fields. Listing/detail request receipts remain in the KVS `REQUEST_RECEIPTS` record.

```json
{
  "recordType": "jobup-job",
  "recordStatus": "complete",
  "jobId": "5c1870d5-e5d6-418f-9914-eff03a571489",
  "title": "Backend Software Engineer (kDrive)",
  "jobUrl": "https://www.jobup.ch/en/jobs/detail/5c1870d5-e5d6-418f-9914-eff03a571489/",
  "companyName": "infomaniak | The Ethical Cloud",
  "companyUrl": "https://www.infomaniak.com/fr",
  "region": "Genève",
  "employmentType": "Permanent position",
  "workloadPercentage": 100,
  "datePosted": "2026-09-02T10:21:27Z",
  "responsibilities": [
    "Architecture & Design : Participate in the evolution of the backend to support the massive growth and scalability challenges of the kDrive product.",
    "Development of critical features : Design and implement complex features (sharing, rights management, file versioning) ensuring optimal performance."
  ],
  "qualifications": [
    "PHP / Laravel expertise : You have solid experience in modern PHP (version 8+) and master complex architectural patterns. Ideally through the use of the Laravel framework.",
    "Mastery of APIs & Microservices : Ability to design robust, performant and documented APIs for a multi-platform ecosystem (web, desktop, mobile)."
  ],
  "niceToHave": [
    "Experience with Docker / Kubernetes , GitLab CI is a plus.",
    "Experience with distributed storage technologies ( S3, Ceph ) or handling complex file systems."
  ],
  "skills": ["MariaDB", "Laravel", "Golang", "Kubernetes"],
  "benefits": [
    "Be part of a company shaping an ethical cloud that respects privacy, people and the environment.",
    "Work every day in a caring environment, balanced with your personal life and extremely stimulating with people at the forefront of their field who are committed, attentive and passionate about what they do."
  ],
  "dataQuality": {
    "requiredFieldsComplete": true,
    "sourceVerified": true,
    "detailJsonLd": true,
    "identityVerified": true,
    "meaningfulSourceFieldCount": 25
  }
}
```

An abbreviated summary from the same local search run:

```json
{
  "recordType": "run-summary",
  "status": "SUCCEEDED",
  "resultStatus": "COMPLETE",
  "mode": "search",
  "itemCount": 5,
  "jobCount": 5,
  "diagnosticCount": 0,
  "requestCount": 6,
  "successfulRequests": 6,
  "failedRequests": 0,
  "retryCount": 0,
  "sourceBlocked": false,
  "deferred": false,
  "blockedReasons": [],
  "failedUrls": [],
  "localOnly": true
}
```

### API and run artifacts

For automated workflows, call the Actor with its JSON input through the Apify API or the Apify JavaScript client, then read the run's default dataset. See the [Apify API documentation](https://docs.apify.com/api/v2) and [Apify JavaScript client documentation](https://docs.apify.com/api/client/js) for authentication and run-control options. Keep API tokens in a secret store or environment variable; never commit them with Actor input.

The default key-value store keeps `RUN_SUMMARY` (also exposed through the `OUTPUT` and `OUTPUT_SUMMARY` compatibility keys), `RUN_DIAGNOSTICS`, `RUN_HEALTH`, `REQUEST_RECEIPTS`, and `RUN_METADATA`. `status` is the Apify platform outcome (`SUCCEEDED` or `FAILED`); `resultStatus` describes the data outcome (`COMPLETE`, `LIMITED`, `SKIPPED`, `DEFERRED`, `NO_DATA`, or `FAILED`). Dataset rows are complete jobs; diagnostics and request receipts are run-level evidence, not job records. A source denial or visible security challenge stops the run with `status: SUCCEEDED` and `resultStatus: SKIPPED`, preserves its evidence, and prevents buffered partial rows from being published.

### FAQ and troubleshooting

- **Why are there fewer rows than listing cards?** The Actor follows detail pages sequentially and emits only complete, identity-matched records with more than 20 meaningful source facts. URLs, identifiers, receipts, aliases, and Actor provenance do not inflate that count. `maxItems` and `maxRequests` may stop work earlier.
- **Why is a field missing?** Jobup does not publish every field for every role. Optional values such as salary are omitted unless present in the ordinary public response; login-gated or rendered-only values are not inferred.
- **Where do I find a failure reason?** Check `RUN_SUMMARY`, `RUN_DIAGNOSTICS`, and `REQUEST_RECEIPTS` in the run's default key-value store. Generic transport failures are deferred; explicit access barriers set `resultStatus` to `SKIPPED` without conflating it with Apify's platform status.
- **Can I provide cookies, a proxy, custom headers, or a CAPTCHA solver?** No. Unsupported input fields are rejected, and the Actor does not use alternate identities or access-control workarounds.
- **How should I start a large search?** Begin with one listing page and a small `maxItems`; scale gradually while observing runtime, request counts, and your Apify plan's compute and storage usage.

### Limits, cost, and responsible use

For a small check, begin with one page and a low `maxItems`; each result requires a detail-page request after listing discovery. Request spacing is sequential, so increasing page and item limits also increases run time. Apify platform compute and storage charges depend on your account plan and actual run usage; estimate from a small local or cloud run before scaling.

This is an independent third-party Actor and is not affiliated with or endorsed by Jobup.ch or Infomaniak. It collects public job-posting content and does not submit applications or access applicant accounts. Use it only for information you are permitted to collect, minimize retention, and follow Jobup.ch's current terms, applicable privacy requirements, and laws. If Jobup returns an access denial, CAPTCHA, human-verification prompt, or security challenge, the Actor stops and marks the run `SKIPPED`; it does not try another route or identity. For questions or improvements, use the Actor's Apify Store Issues tab.

# Actor input Schema

## `mode` (type: `string`):

Search a public listing, enrich one exact job URL, or enrich several exact job URLs. Runtime validation checks that the selected mode matches the supplied URL field.

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

Public Jobup.ch listing pages used in search mode; do not combine with jobUrls or jobUrl.

## `jobUrls` (type: `array`):

Public Jobup.ch detail URLs for multiple mode; use exactly one item for single mode. Do not combine with jobUrl.

## `jobUrl` (type: `string`):

Convenience alias for one exact public detail URL in single mode; do not combine with jobUrls.

## `searchQuery` (type: `string`):

Term sent to the public Jobup.ch listing as the term query.

## `term` (type: `string`):

Alias for searchQuery; searchQuery takes precedence if both are provided.

## `page` (type: `integer`):

First public result page.

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

Bounded number of public result pages in search mode.

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

Maximum complete public jobs to emit.

## `timeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## `maxRetries` (type: `integer`):

Bounded retries for transient HTTP 408, 425, and 5xx responses. Access denials and generic transport failures stop without retry.

## `requestDelayMs` (type: `integer`):

Minimum spacing between sequential public requests in milliseconds.

## `maxRequests` (type: `integer`):

Hard upper bound for listing and detail requests.

## `maxResponseBytes` (type: `integer`):

Safety cap for one public HTML response.

## Actor input object example

```json
{
  "mode": "search",
  "page": 1,
  "maxPages": 1,
  "maxItems": 5,
  "timeoutSecs": 20,
  "maxRetries": 1,
  "requestDelayMs": 500,
  "maxRequests": 50,
  "maxResponseBytes": 10000000
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset; blocked or incomplete pages never become job rows, and buffered jobs are discarded if the source later denies access.

## `runSummary` (type: `string`):

No description

## `runDiagnostics` (type: `string`):

No description

## `runHealth` (type: `string`):

No description

## `requestReceipts` (type: `string`):

No description

## `metadata` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/jobup-ch-jobs-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/jobup-ch-jobs-search-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 '{}' |
apify call jobsapi/jobup-ch-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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