# Platsbanken Jobs Scraper (`automation-lab/sweden-platsbanken-jobs-scraper`) Actor

Search and export public Platsbanken jobs with employers, locations, salary type, working terms, dates, and application links for recruiting and labor-market analysis.

- **URL**: https://apify.com/automation-lab/sweden-platsbanken-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (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 job extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Platsbanken Jobs Scraper

Search and export **Platsbanken jobs** from Sweden's public JobTech vacancy feed.
Get structured employer, location, salary type, working terms, publication dates,
deadlines, descriptions, and application links without operating a browser.

Use the Actor for recurring recruiting research, named-employer hiring signals,
job-feed ingestion, and Swedish labor-market analysis.

### What does Platsbanken Jobs Scraper do?

The Actor searches the official public data feed behind Arbetsförmedlingen's
Platsbanken service. It turns each matching vacancy into one normalized dataset
row.

You can:

- search by role, skill, employer, or phrase;
- filter by Swedish municipality or region;
- target official JobTech occupation fields and groups;
- restrict results by publication date;
- monitor one employer by name or organization number;
- export up to 10,000 matching jobs per run;
- include plain-text or formatted descriptions;
- download results as JSON, CSV, Excel, XML, RSS, or HTML.

The default dataset contains complete job records. There is no separate detail
record or detail charge.

### Who is this Actor for?

#### Recruiters and staffing teams

Build current candidate-sourcing lists by role and city. Keep the employer,
workplace, deadline, and apply URL beside every opening.

#### Sales and account intelligence teams

Monitor named employers for new hiring activity. Swedish organization numbers
help match vacancy records to CRM accounts when the source publishes them.

#### Job boards and aggregators

Collect stable JobTech vacancy IDs, canonical Platsbanken URLs, descriptions,
and external application links for a downstream feed.

#### Labor-market analysts

Repeat the same region and occupation-taxonomy query on a schedule. Compare
employer, occupation, vacancy-count, and work-term distributions over time.

#### Data and automation teams

Send typed records to Google Sheets, a warehouse, Make, Zapier, or an internal
API without maintaining a scraper or browser fleet.

### Why use the official JobTech data route?

The Actor uses the public JSON API that serves Platsbanken vacancy data.
That route is faster and less fragile than parsing rendered pages.

Benefits include:

- no login or API key for the source;
- no browser or proxy configuration;
- stable source IDs for deduplication;
- source-side pagination and taxonomy filters;
- lower memory and transfer use than browser scraping;
- bounded retries for temporary API or network failures.

The Actor does not claim historical vacancies. It exports records available from
the source at run time and matching your input.

### What Platsbanken job data can I extract?

| Group | Included fields |
| --- | --- |
| Identity | JobTech ID, external ID, headline, canonical listing URL |
| Employer | Name, workplace, organization number, website |
| Location | Municipality, region, codes, city, postcode, street, coordinates, workplace model |
| Occupation | Occupation, concept ID, occupation group, occupation field |
| Working terms | Employment type, duration, working-hours type, scope percentage |
| Salary | Salary type and source-provided salary description |
| Dates | Publication date, last publication date, application deadline |
| Application | Application URL, public application email, reference |
| Description | Plain text and optional formatted HTML |
| Skills | Required and preferred JobTech taxonomy labels |
| Context | Vacancy count, source type, query, source total, scrape timestamp |

Fields remain `null` when the employer or source does not publish a value.
Empty skill lists are returned as arrays.

### How to scrape Platsbanken jobs

1. Open the Actor input in Apify Console.
2. Enter a keyword such as `developer`, `sjuksköterska`, or `Volvo`.
3. Optionally add municipality names, municipality codes, or region codes.
4. Add an employer or JobTech occupation taxonomy filter if needed.
5. Choose the maximum number of matching jobs.
6. Run the Actor.
7. Open the **Dataset items** output.
8. Download or integrate the dataset in your preferred format.

For a quick evaluation, start with 10 records. For scheduled work, test your
exact filters before increasing `maxItems`.

### Input parameters

| Input | Type | Default | Purpose |
| --- | --- | --- | --- |
| `query` | string | `developer` | Role, skill, employer, or phrase; empty means newest jobs |
| `locations` | string array | `[]` | Municipality/region names or official numeric codes |
| `employer` | string | — | Employer name, workplace, or organization-number substring |
| `occupationFields` | string array | `[]` | Official JobTech occupation-field concept IDs |
| `occupationGroups` | string array | `[]` | Official JobTech occupation-group concept IDs |
| `publishedAfter` | string | — | ISO date or timestamp lower bound |
| `publishedBefore` | string | — | ISO date or timestamp upper bound |
| `maxItems` | integer | `100` | Maximum saved jobs, from 1 to 10,000 |
| `includeDescriptionHtml` | boolean | `false` | Add formatted HTML descriptions |
| `includeSearchTotal` | boolean | `true` | Add the source match count to each row |

Date-only values such as `2026-08-01` are accepted. The Actor rejects invalid
dates and a lower bound later than the upper bound.

Two-digit location codes are sent as region filters. Four-digit location codes
are sent as municipality filters. Other values are matched case-insensitively
against returned municipality, region, city, and country names.

### Example input: Stockholm developer jobs

```json
{
  "query": "developer",
  "locations": ["Stockholm"],
  "maxItems": 10,
  "includeDescriptionHtml": false,
  "includeSearchTotal": true
}
```

A current local test of this input returned 10 matching records from a source
result set of 648.

### Example input: monitor a Swedish employer

```json
{
  "query": "Volvo",
  "employer": "Volvo",
  "maxItems": 50,
  "includeDescriptionHtml": false,
  "includeSearchTotal": true
}
```

Schedule this input daily or weekly and deduplicate downstream by `jobId` to
track current named-account hiring signals.

### Example input: Data/IT labor-market analysis

```json
{
  "query": "developer",
  "locations": ["01"],
  "occupationFields": ["apaJ_2ja_LuF"],
  "maxItems": 200,
  "includeDescriptionHtml": false,
  "includeSearchTotal": true
}
```

Region code `01` selects Stockholms län. `apaJ_2ja_LuF` is the JobTech Data/IT
occupation field used in this example.

### Example output

This shortened record reflects the Actor's current output shape:

```json
{
  "jobId": "31371444",
  "headline": "Backend Developer",
  "webpageUrl": "https://arbetsformedlingen.se/platsbanken/annonser/31371444",
  "applicationUrl": "https://recruit.agile.nu/apply/jp-cec71f71f3e818e6?source=platsbanken",
  "publicationDate": "2026-07-31T09:12:04",
  "applicationDeadline": "2026-09-10T23:59:59",
  "employerName": "Agile Resources AB",
  "workplaceMunicipality": "Stockholm",
  "workplaceRegion": "Stockholms län",
  "employmentType": "Vanlig anställning",
  "workingHoursType": "Heltid",
  "salaryType": "Fast månads- vecko- eller timlön",
  "searchQuery": "developer",
  "searchTotal": 648,
  "scrapedAt": "2026-09-07T12:30:00.000Z"
}
```

The actual dataset also includes occupation taxonomy, scope, description,
skills, organization number, workplace address, and other documented fields.

### How much does it cost to export Platsbanken jobs?

The Actor uses pay-per-event pricing:

- one `start` event per run;
- one `job` event for every complete vacancy saved.

At the BRONZE tier, the start event is **$0.001** and each saved job is
**$0.002**. For any run, multiply the number of saved jobs by the applicable per-job rate,
then add the one-time start fee. For example, a 10-job run has 10 job events,
a 100-job run has 100 job events, and a 1,000-job export has 1,000 job events.

Your Apify tier can use a different per-job rate. The Console shows the
applicable price before the run. Filtered-out, duplicate, malformed, or failed
records are not charged as jobs.

### Pagination, limits, and filtering behavior

The Actor requests up to 100 source rows at a time. Official numeric location,
occupation, query, and date filters are sent to JobTech before pagination.
Textual location and employer filters are applied to typed source records.

`maxItems` controls matching rows saved, not raw source rows inspected. A narrow
employer or textual-location filter can therefore require more source pages than
a broad query.

Every stable `jobId` is emitted at most once per run. The Actor stops when it
reaches `maxItems` or the source reports no more results.

### Reliability and failure behavior

Each source request has a 30-second timeout. Temporary network errors, HTTP 429,
and server errors receive up to three attempts with backoff.

The Actor fails instead of returning a misleading empty success when the API
returns malformed JSON, an unexpected content type, or a stable request error.
A valid query with no current matches finishes successfully with an empty
dataset.

No automatic residential proxy, browser, session, or paid source fallback is
enabled.

### Recurring monitoring workflow

1. Choose a stable query and filters.
2. Keep `includeSearchTotal` enabled for market-size context.
3. Schedule the Actor at your desired interval.
4. Store `jobId`, `publicationDate`, and `lastPublicationDate` downstream.
5. Compare each run with the prior snapshot.
6. Route newly observed IDs to recruiters, alerts, or analytics.

The Actor itself does not maintain cross-run state or label records as new,
changed, or removed. This keeps every run reproducible and lets your destination
system define retention rules.

### Export and integration options

Use Apify integrations to send the default dataset to:

- Google Sheets for recruiter review;
- Make or Zapier for workflow automation;
- Slack or email through your own alert scenario;
- BigQuery, Snowflake, PostgreSQL, or object storage;
- a webhook-backed internal job ingestion service.

CSV and Excel work well for ad hoc analysis. JSON preserves arrays and nullable
fields for programmatic processing.

### Run with the Apify API using cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~sweden-platsbanken-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"developer","locations":["Stockholm"],"maxItems":10}'
```

Use the returned run's default dataset ID to fetch output after completion.
Never commit your Apify token to source control.

### Run with JavaScript

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor(
  'automation-lab/sweden-platsbanken-jobs-scraper'
).call({
  query: 'developer',
  locations: ['Stockholm'],
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor(
    "automation-lab/sweden-platsbanken-jobs-scraper"
).call(run_input={
    "query": "developer",
    "locations": ["Stockholm"],
    "maxItems": 100,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use Platsbanken Jobs Scraper with MCP

Add the Actor to Claude Code through Apify's MCP server:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/sweden-platsbanken-jobs-scraper"
```

For **Claude Desktop**, **Cursor**, or **VS Code**, use this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/sweden-platsbanken-jobs-scraper"
    }
  }
}
```

Example prompts showing MCP usage include:

- “Using MCP, find 25 Platsbanken developer jobs in Stockholm and group them by employer.”
- “Export current Volvo vacancies from Sweden with deadlines and apply URLs.”
- “Collect Data/IT vacancies in region 01 for my weekly hiring dashboard.”

### Responsible use and legality

The Actor accesses public vacancy data and does not bypass authentication.
You are responsible for your use of the output and for complying with applicable
source terms, data-protection rules, marketing rules, and employment law.

Vacancies can contain public contact details supplied for recruitment. Use those
details only for appropriate purposes. Avoid unsolicited bulk messaging,
profiling individuals, or retaining personal data longer than necessary.

Do not present a vacancy as current without checking its deadline and latest
source state.

### Troubleshooting

#### Why did the run return fewer jobs than `maxItems`?

The source may have fewer matches, or your employer/text-location filter may
exclude source hits. Review `searchTotal`, loosen filters, and test a broader
query.

#### Why is a salary description null?

Many Swedish vacancies state only a salary type or omit compensation details.
The Actor returns source values and does not estimate missing salaries.

#### Why did the run fail with an input error?

Check that `maxItems` is an integer from 1 to 10,000, arrays contain strings,
and date filters are valid ISO dates. `publishedAfter` cannot be later than
`publishedBefore`.

#### Why did the source request fail?

Inspect the run log for the final status. Temporary failures are retried three
times. A persistent source outage or invalid API filter fails the run so you can
retry later without treating missing data as a real empty market.

### Limitations

- Results reflect the current public JobTech feed, not a historical archive.
- Completeness and field availability depend on source and employer data.
- Salary amount is often absent; the Actor never infers it.
- Free-text employer and location filters are substring matches.
- The Actor does not translate Swedish labels or descriptions.
- It does not send alerts or compare prior runs by itself.
- Upstream API changes or outages can interrupt runs.

### Related Automation Lab Actors

- [InfoJobs Spain Jobs Scraper](https://apify.com/automation-lab/infojobs-spain-jobs-scraper) for Spanish vacancy monitoring.
- [Arbeitnow EU and DACH Jobs Scraper](https://apify.com/automation-lab/arbeitnow-eu-dach-jobs-scraper) for European and DACH job feeds.
- [Remote OK Jobs Feed Scraper](https://apify.com/automation-lab/remoteok-remote-jobs-feed) for remote-first vacancies.

Choose this Actor when you need Sweden's official Platsbanken/JobTech data and
Swedish location, occupation, and employer fields.

### FAQ

#### Does the Actor require a Platsbanken account?

No. It uses the public JobTech vacancy API and requires no source login.

#### Does it require an Apify proxy?

No. The current implementation makes direct HTTPS requests to the public API.

#### Can I export every current job?

Leave `query` empty and raise `maxItems`. Large broad exports take more requests
and cost one job event per saved vacancy.

#### Can I search by organization number?

Yes. Put the public organization number in `employer`. It is matched against the
employer metadata returned by JobTech.

#### How should I identify duplicates across scheduled runs?

Use `jobId` as the stable source identifier. Keep publication timestamps and
application deadlines to interpret changes over time.

#### Are descriptions included?

Plain text is included by default. Enable `includeDescriptionHtml` when your
destination needs the source's formatted description.

#### Are filtered-out records charged?

No. The `job` event is emitted only for accepted records pushed to the default
dataset.

# Actor input Schema

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

Role, skill, employer, or phrase to search for. Leave empty to export the newest matching vacancies.

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

Municipality or region names (such as Stockholm or Göteborg), municipality codes (0180), or region codes (01). Codes are filtered by the source API; names are matched against returned addresses.

## `employer` (type: `string`):

Only save vacancies whose employer name, workplace, or organization number contains this value.

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

Maximum number of matching vacancy records to save.

## `publishedAfter` (type: `string`):

Only include vacancies published after this ISO date or timestamp, for example 2026-08-01.

## `publishedBefore` (type: `string`):

Only include vacancies published before this ISO date or timestamp.

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

Optional JobTech taxonomy field IDs, such as apaJ\_2ja\_LuF for Data/IT.

## `occupationGroups` (type: `array`):

Optional JobTech taxonomy occupation-group IDs.

## `includeDescriptionHtml` (type: `boolean`):

Include the source's formatted HTML description as well as plain text.

## `includeSearchTotal` (type: `boolean`):

Add the total number of source matches to every saved row.

## Actor input object example

```json
{
  "query": "developer",
  "locations": [
    "Stockholm"
  ],
  "maxItems": 20,
  "includeDescriptionHtml": false,
  "includeSearchTotal": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset containing normalized Platsbanken job vacancies.

# 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": "developer",
    "locations": [
        "Stockholm"
    ],
    "maxItems": 20,
    "includeDescriptionHtml": false,
    "includeSearchTotal": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sweden-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": "developer",
    "locations": ["Stockholm"],
    "maxItems": 20,
    "includeDescriptionHtml": False,
    "includeSearchTotal": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sweden-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": "developer",
  "locations": [
    "Stockholm"
  ],
  "maxItems": 20,
  "includeDescriptionHtml": false,
  "includeSearchTotal": true
}' |
apify call automation-lab/sweden-platsbanken-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/sweden-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/Ya21aX8Z5jrQm8jMc/builds/XqafOBejBROjVr1gq/openapi.json