# Coople Switzerland Scraper — Temp & Gig Staffing Job Listings (`studio-amba/coople-scraper`) Actor

Scrape job listings from Coople, Switzerland's leading flexible/temp staffing platform. Titles, locations, hourly wages and full descriptions. No login or cookies required.

- **URL**: https://apify.com/studio-amba/coople-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Coople Switzerland Scraper

Extract job listings from [Coople](https://www.coople.com/ch/jobs), Switzerland's leading flexible/temp staffing platform, as clean structured JSON. Get job titles, locations, hourly wages, shift counts and full German-language descriptions in one run — no login, no cookies, no browser automation.

Coople places workers into short-term shifts and temp assignments across hospitality, retail, logistics, healthcare, events and office roles for over 30,000 Swiss companies. This actor reads Coople's own public jobs feed directly.

### What this actor does

Given an optional keyword and/or location, this actor collects the matching job listings from Coople Switzerland and returns one row per assignment with:

- Job title and Coople's internal job-profile category
- City, postal code and canton (when disclosed)
- Hourly wage and total estimated assignment pay, in CHF
- Full requirements/description text and clothing requirements
- Shift count, total scheduled work duration, and assignment date range
- Publication date, the assignment's unique ID and direct URL

### Why use it

- **Swiss gig/temp-labour market research** — track what shift work Switzerland's largest flexible-staffing platform is filling, where, and at what hourly rate.
- **Wage benchmarking** — Coople discloses the actual hourly rate on every listing, useful for comparing gig/temp pay across cities, cantons and sectors.
- **Recruitment and sourcing** — build a live feed of open shifts for a role or region.
- **Aggregators and job boards** — feed Swiss temp-staffing listings into your own product.

### How to scrape Coople data

1. Open the actor. Leave **Search Query** and **Location filter** empty to browse all current listings — Coople's own site has no keyword search either, it's a plain most-recent-first feed (see Limitations).
2. Optionally set **Search Query** (e.g. `reinigung`, `logistik`, `koch`, `pflege`) to filter by job title or category.
3. Optionally set **Location filter** (e.g. `Zürich`, `Basel`, `8048`) to filter by city, canton or postal code.
4. Set **Max Results** (each kept result triggers one extra request to fetch the full description, so large values take proportionally longer).
5. Leave the proxy on the default automatic setting and click **Start**.

The actor fetches Coople's public jobs feed in pages of 200, applies your filters client-side, then fetches the full detail page for each kept result. Results are written to the dataset as they're collected. Export as JSON, CSV or Excel.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Optional keyword to filter by title/category. Leave empty to browse all listings. |
| `location` | string | Optional city, canton or postal code filter, applied client-side (e.g. `Zürich`, `8048`). |
| `maxResults` | integer | Maximum number of listings to return (max 500). Default: `50`. |
| `proxyConfiguration` | object | Apify proxy settings. Default: automatic (no anti-bot found — see Limitations). |

#### Example input

```json
{
    "searchQuery": "reinigung",
    "location": "Zürich",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

### Output

Each dataset item looks like this (real output from a test run):

```json
{
    "title": "Teamleiter Lebensmittelproduktion",
    "jobProfile": "Küchenchef/in",
    "company": "Coople",
    "locationRaw": "Zürich 8048",
    "city": "Zürich",
    "postalCode": "8048",
    "canton": null,
    "country": "Switzerland",
    "hourlyWage": 35.58,
    "salary": 6351.03,
    "currency": "CHF",
    "description": "Deine Mission als Bereichsleiter:in:\n\nAls Bereichsleiter:in verantwortest du gemeinsam mit der Produktionsleitung den operativen Produktionsbetrieb...",
    "clothingRequirements": "T-Shirt, Pulli und Sicherheitsschuhe werden zur Verfügung gestellt. Frisch gewaschene, dunkle Baumwollhose mitbringen.",
    "shiftsCount": 21,
    "workDurationMinutes": 10710,
    "periodFrom": "2026-09-02T04:00:00.000Z",
    "periodTo": "2026-09-30T13:30:00.000Z",
    "datePublished": "2026-08-25T15:32:11.000Z",
    "jobId": "8a1e0b3c-45ab-44cb-bac0-6ecdb0da3a8c",
    "waReadableId": "60261033496",
    "url": "https://www.coople.com/ch/jobs/8a1e0b3c-45ab-44cb-bac0-6ecdb0da3a8c",
    "source": "coople.com/ch",
    "scrapedAt": "2026-09-02T09:13:34.617Z",
    "searchQuery": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title as posted |
| `jobProfile` | string | Coople's internal category name, when the title itself is generic |
| `company` | string | Always `"Coople"` — Coople is the legal employer under Switzerland's temp-staffing model, so no separate hiring company is disclosed |
| `locationRaw` | string | Location as shown on the listing |
| `city` | string | City/locality of the assignment |
| `postalCode` | string | Swiss postal code |
| `canton` | string | Canton, when disclosed (often empty on the source) |
| `country` | string | Always `"Switzerland"` |
| `hourlyWage` | number | Hourly pay rate, in `currency` |
| `salary` | number | Estimated total pay for the full assignment, in `currency` |
| `currency` | string | ISO currency code — `CHF` on every sampled listing, never converted |
| `description` | string | Full requirements/description text (German) |
| `clothingRequirements` | string | Dress code or workwear requirements, when specified |
| `shiftsCount` | integer | Number of shifts in the assignment |
| `workDurationMinutes` | integer | Total scheduled work duration across all shifts, in minutes |
| `periodFrom` | string | ISO 8601 timestamp of the first shift |
| `periodTo` | string | ISO 8601 timestamp of the last shift |
| `datePublished` | string | ISO 8601 publication timestamp |
| `jobId` | string | Coople's internal work-assignment ID |
| `waReadableId` | string | Coople's human-readable job reference number |
| `url` | string | Direct job listing URL |
| `source` | string | Source site identifier (`coople.com/ch`) |
| `scrapedAt` | string | ISO 8601 timestamp of collection |
| `searchQuery` | string | Input echo — the `searchQuery` used for this run, if any |

### Cost estimate

The actor makes one lightweight lookup request, one or more list-page requests (200 results per page), plus one extra request per kept result to fetch the full description. For a typical run of 20-50 results this is well under a hundred requests total, no browser overhead. Usage is only charged after a run finishes with status SUCCEEDED — a failed or aborted run doesn't bill for partial results.

### Limitations

- **Switzerland only.** Coople's site shows country-path variants (`/uk`, `/de`, `/at`, `/fr`, `/nl`, `/be`, `/it`, `/es`), but verified live (Sep 2026): only `/ch` has a working, populated public-jobs API (897-900 listings). `/uk` exists on the site shell but its own API returns zero live postings right now. Every other country path 404s on the actual jobs API. This is Coople's real market coverage today, not a scraper limitation — the roster gets revisited if Coople relaunches a market with live postings.
- **No server-side search.** Coople's public jobs page has no keyword search or filter UI at all — every candidate query parameter tested (`keyword`, `keywords`, `industryIds`, `jobProfileId`) was silently ignored by the API. `searchQuery` and `location` here are applied client-side against the fetched feed.
- **German only.** Listings are published in German (Swiss High German); no working language negotiation was found.
- **Canton is often empty.** Coople's own `state` field is blank on many listings even though city/postal code are always present.
- **Usage cost only settles once a run reports SUCCEEDED** — reading a dataset mid-run shows a cost far below the real total.

### Related scrapers

Building a European staffing and public-employment dataset? These sibling actors follow the same clean-JSON approach:

- **Adecco Multi-Country Scraper** — Adecco across BE/NL/FR/ES/IT/PL
- **Randstad Belgium Scraper** — Randstad's Belgian job board
- **Zentraljob.ch Scraper** — Central Switzerland regional job board
- **Jobbird Scraper** — Dutch general job board
- **Manpower Scraper** — Manpower staffing listings

### Disclaimer

This actor collects publicly available data from Coople for legitimate research and aggregation use. Respect Coople's terms of service and applicable data protection law when using the output.

# Actor input Schema

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

Optional keyword to filter listings by title/category (e.g. 'reinigung', 'logistik', 'koch', 'pflege'). Coople's own site has no functional keyword search — this filters the fetched feed client-side. Leave empty to browse all current listings (recommended, matches the site's own default view).

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

Optional city, canton or postal code to filter results by (e.g. 'Zürich', 'Basel', '8048'). Applied client-side — Coople's API does not expose a working location filter parameter.

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

Maximum number of job listings to return. Each kept result triggers one extra request to fetch the full description — large values take proportionally longer.

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

Proxy settings. coople.com has no anti-bot protection (verified live) — the free automatic Apify proxy pool works fine, no residential proxy needed.

## Actor input object example

```json
{
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/coople-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 = {
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/coople-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 '{
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/coople-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/coople-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/5HC9Tnx4gdLOvjcGR/builds/80mNn78si95gYYE44/openapi.json