# Platsbanken Scraper — Sweden Jobs, Salary & Employers (`logiover/platsbanken-jobs-scraper`) Actor

Scrape every public job ad in Sweden from the official Platsbanken/JobTech feed: title, employer name with phone, email and organisation number, workplace address, salary, employment type and apply URL. Keyless, no login. Export JSON, CSV or Excel.

- **URL**: https://apify.com/logiover/platsbanken-jobs-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 66 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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

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

## Platsbanken Scraper — Sweden Jobs, Salary & Employers

Export every publicly advertised job in Sweden — with the employer's phone number, e-mail and organisation number attached — straight to JSON, CSV or Excel.

### What does Platsbanken Scraper do?

This Actor reads Sweden's official job feed: every ad published to **Platsbanken** by Arbetsförmedlingen, exposed through the **JobTech Development** search API. There is no API key, no login and no cookie to supply — the source is open public-sector data, which makes runs stable and fast.

Around **40 000 ads** are online at any moment. The API refuses to page past offset 2000 on a single query, so a naive scraper stops at 2 000 rows. This Actor slices the country by **occupation field** (and optionally by region), paginates each slice independently and de-duplicates by ad ID, which is what lets one run return tens of thousands of unique rows.

Every row carries 44 fields, including the employer's registered **organisation number, phone and e-mail** — the details that turn a job listing into a usable B2B lead.

### Who is it for?

- **Recruitment agencies** mapping which employers are hiring, in which municipality, right now.
- **Staffing and RPO sales teams** who need a call list of companies with open vacancies.
- **HR-tech and ATS vendors** prospecting employers that publish roles regularly.
- **Labour-market analysts and economists** tracking demand by occupation, region and salary type.
- **Job-board operators** filling a Swedish market feed without negotiating a data licence.

### Use cases

- Build a weekly lead list of every Swedish employer hiring warehouse staff in Skåne, complete with phone numbers.
- Track how many nursing vacancies open per region per month to size a regional expansion.
- Feed a niche job board with fresh, licence-free Swedish listings including apply URLs.
- Alert a sales team the moment a target account posts its first developer role.
- Analyse which skills appear as required versus preferred across an occupation over time.

### Why use this Actor?

- **Keyless** — no account, no API key, no login. Runs work out of the box.
- **44 structured fields** per ad, including employer contact data and geo coordinates.
- **Breaks the 2000-row API ceiling** by slicing on occupation field automatically.
- **Real filters** — keyword, occupation field, region, published-within-N-days, remote-only.
- **Official source** — data comes from the government feed, not a fragile HTML page.
- **Export anywhere** — JSON, CSV, Excel, or straight into your database through the Apify API.

### What data can you extract?

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Unique JobTech ad ID |
| `title` | string | Job title as advertised |
| `occupation` | string | Normalised occupation label |
| `occupationField` | string | Broad occupation field |
| `occupationGroup` | string | Occupation group (SSYK-based) |
| `employerName` | string | Registered employer name |
| `employerWorkplace` | string | Specific workplace or unit |
| `organisationNumber` | string | Swedish organisation number |
| `employerPhone` | string | Employer or contact phone |
| `employerEmail` | string | Employer or contact e-mail |
| `employerUrl` | string | Employer website |
| `contactName` | string | Named recruitment contact |
| `contactDescription` | string | Contact's role |
| `city` | string | Municipality (kommun) |
| `region` | string | Region (län) |
| `country` | string | Country |
| `streetAddress` | string | Workplace street address |
| `postcode` | string | Postcode |
| `latitude` / `longitude` | number | Workplace coordinates |
| `employmentType` | string | Permanent, temporary, seasonal … |
| `durationType` | string | Contract duration |
| `workingHoursType` | string | Full-time or part-time |
| `scopeOfWorkMin` / `scopeOfWorkMax` | number | Employment scope in percent |
| `salaryType` | string | Fixed, commission, by agreement … |
| `salaryDescription` | string | Free-text salary note |
| `numberOfVacancies` | number | Positions available in the ad |
| `experienceRequired` | boolean | Whether experience is required |
| `drivingLicenseRequired` | boolean | Driving licence required |
| `ownCarRequired` | boolean | Access to own car required |
| `mustHaveSkills` | string | Required skills, comma-separated |
| `niceToHaveSkills` | string | Preferred skills, comma-separated |
| `applicationDeadline` | string | Last application date |
| `applicationUrl` | string | Direct apply URL |
| `applicationEmail` | string | Application e-mail |
| `applicationReference` | string | Employer's reference code |
| `publicationDate` | string | First published |
| `lastPublicationDate` | string | Last republished |
| `adUrl` | string | Public ad page |
| `logoUrl` | string | Employer logo |
| `description` | string | Full ad text |
| `source` | string | Always `platsbanken_jobtech` |
| `scrapedAt` | string | Run timestamp (ISO 8601) |

#### Example output

```json
{
  "jobId": "29357771",
  "title": "Systemutvecklare .NET",
  "occupation": "Systemutvecklare/Programmerare",
  "occupationField": "Data/IT",
  "employerName": "HÖGSKOLAN I HALMSTAD",
  "organisationNumber": "2021003203",
  "employerPhone": "+46 35 16 71 00",
  "employerEmail": "jobb@hh.se",
  "employerUrl": "http://www.hh.se/omhogskolan/jobbahososs.2064.html",
  "city": "Halmstad",
  "region": "Hallands län",
  "streetAddress": "Kristian IV:s väg 3",
  "employmentType": "Vanlig anställning",
  "workingHoursType": "Heltid",
  "salaryType": "Fast månads- vecko- eller timlön",
  "numberOfVacancies": 2,
  "mustHaveSkills": "C#, .NET, SQL",
  "applicationDeadline": "2026-09-01",
  "applicationUrl": "https://arbetsformedlingen.se/platsbanken/annonser/29357771",
  "publicationDate": "2026-08-05T09:12:00",
  "source": "platsbanken_jobtech"
}
```

### How to use it

1. Type a keyword — or leave it empty to export the whole market.
2. Optionally narrow by region, occupation field, remote-only, or a published-within-N-days window.
3. Set **Maximum results**. Under 2 000 the Actor runs one fast query; above that it automatically slices by occupation field to go deeper.
4. Run, then download JSON, CSV or Excel — or pull the dataset from the Apify API.

### Input example

```json
{
  "query": "sjuksköterska",
  "publishedAfterDays": 30,
  "maxResults": 5000
}
```

### Notes and limits

- The feed contains ads **currently published**. Expired ads leave the feed, so run on a schedule to build history.
- Contact fields are populated only when the employer chose to publish them; roughly half of all ads carry a phone or e-mail.
- A single API query cannot page past 2 000 rows. The Actor works around this by slicing, but a very narrow keyword combined with a very high maximum will simply run out of matching ads.
- Data originates from Arbetsförmedlingen and is redistributed under Swedish open-data terms. You are responsible for how you use personal contact details, including under GDPR.

### FAQ

**Do I need an API key or a Swedish account?**
No. The JobTech feed is open public data and this Actor needs nothing from you.

**Can I get more than 2 000 results?**
Yes. Set a higher maximum and the Actor splits the run by occupation field automatically.

**Is the employer's phone number always there?**
No — it is present when the employer published it. `employerPhone`, `employerEmail` and `contactName` are `null` otherwise, so you can filter on them.

**How fresh is the data?**
Ads appear in the feed as soon as they go live on Platsbanken, typically within minutes.

**How am I charged?**
Pay per result: you pay for the job ads the Actor delivers, nothing else.

***

\*Maintained: last verified 2026-09-01 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/platsbanken-jobs-scraper/changelog.md

# Actor input Schema

## `query` (type: `string`):

Free-text search across job title, description and employer, e.g. "utvecklare", "sjuksköterska" or "warehouse". Leave empty to pull every currently published ad in Sweden.

## `occupationFields` (type: `array`):

Optional JobTech occupation-field concept IDs to restrict the run. Leave empty and the Actor discovers them automatically when a run needs to pass the API's 2000-row page limit.

## `regions` (type: `array`):

Optional JobTech region concept IDs (län), e.g. "CifL_Rzy_Mku" for Stockholm. Leave empty for all of Sweden.

## `publishedAfterDays` (type: `integer`):

Only return ads published in the last N days. 0 disables the filter and returns every ad currently online.

## `remoteOnly` (type: `boolean`):

Return only ads flagged as remote-friendly by the employer.

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

Stop after this many ads. Sweden publishes roughly 40 000 ads at any moment, so raise this for a full-market export.

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

The feed is a keyless public API; the default datacenter proxy is enough.

## Actor input object example

```json
{
  "query": "utvecklare",
  "occupationFields": [],
  "regions": [],
  "publishedAfterDays": 30,
  "remoteOnly": false,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All records from this run.

# 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 = {
    "query": "utvecklare",
    "occupationFields": [],
    "regions": [],
    "publishedAfterDays": 30,
    "remoteOnly": false,
    "maxResults": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/platsbanken-jobs-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 = {
    "query": "utvecklare",
    "occupationFields": [],
    "regions": [],
    "publishedAfterDays": 30,
    "remoteOnly": False,
    "maxResults": 1000,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/platsbanken-jobs-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 '{
  "query": "utvecklare",
  "occupationFields": [],
  "regions": [],
  "publishedAfterDays": 30,
  "remoteOnly": false,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call logiover/platsbanken-jobs-scraper --silent --output-dataset

```

## MCP server setup

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