# Arbetsformedlingen Jobs Scraper (`clack/arbetsformedlingen-jobs-scraper`) Actor

Scrape job listings from Sweden's Public Employment Service (Arbetsförmedlingen). Filter by occupation, location, employment type, experience level & more. Export comprehensive job data including titles, companies, dates, salaries & full descriptions.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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

## 🇸🇪 Arbetsförmedlingen Jobs Scraper

Powerful Apify Actor that fetches job listings from Arbetsförmedlingen (Swedish Public Employment Service) with advanced filtering options and deep search capabilities. Extract comprehensive Swedish job market data for recruitment, research, and analysis.

### 🚀 Features

- **🔍 Flexible Search**: Search by keywords, occupations, locations, and multiple other criteria
- **📊 Deep Search Mode**: Fetch comprehensive job details including company information, requirements, and contact details
- **🎯 Smart Filtering**: Filter by employment type, work extent, education requirements, remote work options, and more
- **⚡ Batch Processing**: Efficiently fetch multiple job listings with concurrent API requests
- **📋 Structured Output**: Returns data in a clean, structured JSON format ready for analysis
- **🌍 Location Support**: Search across all Swedish regions and municipalities
- **💼 Occupation Categories**: Support for all major Swedish occupation classifications

### 📋 Use Cases

This actor is perfect for:

- **Recruiters**: Monitor job market trends and competitor hiring activities
- **Job Seekers**: Automate job search across specific criteria
- **Market Researchers**: Analyze Swedish labor market trends and salary data
- **HR Departments**: Benchmark salaries and job requirements
- **Career Counselors**: Track in-demand skills and occupations
- **Data Scientists**: Collect job market data for analysis and modeling

### 🎯 Input Parameters

The actor accepts the following input parameters:

| Parameter | Type | Required | Description | Example |
|-----------|------|----------|-------------|---------|
| `search_term` | String | No | Free text search for job title, description, or company | "utvecklare", "projektledare" |
| `occupations` | Array | No | Filter by occupation categories | \["IT", "Data/IT"] |
| `locations` | Array | No | Filter by regions (län) or municipalities | \["Stockholm", "Skåne län"] |
| `publishedAt` | String | No | Filter by publication date | "last-24h", "last-week" |
| `employmentTypes` | Array | No | Filter by employment type | \["Tillsvidare", "Visstid"] |
| `workExtent` | String | No | Filter by work extent | "Heltid", "Deltid" |
| `drivingLicenseRequired` | Boolean | No | Filter jobs requiring driving license | false |
| `remote` | Boolean | No | Filter for remote work opportunities | true |
| `sort_by` | String | No | Sort results by relevance or date | "date" |
| `results_limit` | Integer | No | Maximum number of results (1-500) | 100 |
| `deepSearch` | Boolean | No | Fetch detailed information for each job | true |
| `requiresExperience` | Boolean | No | Set to false for entry-level positions | false |

#### 📍 Supported Locations

- **All Swedish Regions (Län)**: Stockholm, Västra Götaland, Skåne, etc.
- **All Swedish Municipalities**: Over 290 municipalities supported
- **Special Options**: Abroad positions, unspecified locations in Sweden

#### 💼 Occupation Categories

```
IT, Data/IT
Administration, ekonomi, juridik
Hälsa, vård, omsorg
Pedagogiskt arbete
Tekniskt arbete
... and 30+ more categories
```

### 📦 Output Format

#### Standard Output (deepSearch: false)

```json
{
    "id": "29585195",
    "publishedDate": "2025-03-28T14:12:39Z",
    "lastApplicationDate": "2025-04-27T21:59:59Z",
    "title": "Backend Developer",
    "occupation": "Systemutvecklare",
    "workplace": "Stockholm",
    "workplaceName": "Tech Company AB",
    "unspecifiedWorkplace": false,
    "published": true,
    "positions": 2,
    "link": "https://arbetsformedlingen.se/platsbanken/annonser/29585195"
}
```

#### Deep Search Output (deepSearch: true)

When deep search is enabled, you get all standard fields plus:

- **Detailed Workplace Info**: Full address, coordinates, region details
- **Company Information**: Organization number, website, contact details
- **Job Description**: Complete job description text
- **Requirements**: Education, experience, skills, languages, driving licenses
- **Employment Details**: Salary information, employment conditions, duration
- **Application Info**: How to apply, contact persons, reference numbers

### 💡 Example Configurations

#### 1. Basic Job Search in Stockholm

```json
{
    "search_term": "utvecklare",
    "locations": ["Stockholm"],
    "results_limit": 50
}
```

#### 2. Remote IT Jobs Posted This Week

```json
{
    "occupations": ["Data/IT"],
    "remote": true,
    "publishedAt": "last-week",
    "sort_by": "date",
    "results_limit": 100
}
```

#### 3. Entry-Level Healthcare Positions

```json
{
    "occupations": ["Hälsa, vård, omsorg"],
    "requiresExperience": false,
    "employmentTypes": ["Tillsvidare"],
    "workExtent": "Heltid",
    "results_limit": 200
}
```

#### 4. Comprehensive Regional Search with Details

```json
{
    "locations": ["Västra Götalands län", "Skåne län"],
    "publishedAt": "last-month",
    "drivingLicenseRequired": false,
    "deepSearch": true,
    "results_limit": 150
}
```

### ⚡ Performance

| Configuration | Jobs Count | Execution Time | Memory Usage |
|--------------|------------|----------------|--------------|
| Standard search | 50 jobs | 3-5 seconds | 256 MB |
| Standard search | 500 jobs | 30-40 seconds | 256 MB |
| Deep search | 50 jobs | 6-8 seconds | 256 MB |
| Deep search | 500 jobs | 60-70 seconds | 256 MB |

**Note**: Deep search significantly increases execution time as it fetches detailed information for each job listing. Tests show that 256 MB RAM is sufficient for both standard and deep searches.

### 🔧 Advanced Features

#### Concurrency Control

The actor uses intelligent concurrency control to optimize performance:

- Default: 5 concurrent requests
- Automatically handles rate limiting with exponential backoff
- Retry mechanism for failed requests

#### Error Handling

- Comprehensive error logging
- Graceful handling of failures
- Partial results saved even if some requests fail
- Detailed error output for debugging

### 📊 Summary Statistics

After each run, the actor provides summary statistics in the OUTPUT key-value store:

```json
{
    "totalJobs": 150,
    "deepSearch": true,
    "searchTerm": "utvecklare",
    "executionTime": "32.5s",
    "jobsByEmployer": {
        "Company A": 5,
        "Company B": 3
    },
    "jobsByLocation": {
        "Stockholm": 75,
        "Göteborg": 40
    },
    "jobsByOccupation": {
        "Systemutvecklare": 60,
        "Projektledare": 20
    }
}
```

### 🛠️ Limitations

- Maximum 500 results per run
- Deep search increases execution time significantly
- Some job details may be incomplete depending on employer input
- Content is primarily in Swedish
- Service may have rate limits during peak hours

### 🤝 Support

For issues, feature requests, or questions:

- Create an issue in the Apify actor page
- Contact through the Apify platform
- Check the actor logs for detailed error messages

### 📈 Changelog

#### Version 0.1 (Current)

- Initial release with comprehensive job search
- Support for all Swedish regions and municipalities
- Deep search mode for detailed job information
- Advanced filtering options
- Batch processing with concurrency control
- Summary statistics generation

***

**Keywords**: Swedish jobs, Arbetsförmedlingen, job scraper, Sweden employment, Nordic jobs, Swedish job market, recruitment Sweden, job listings Sweden

# Actor input Schema

## `search_term` (type: `string`):

Free text search for job title, description, or company

## `occupations` (type: `array`):

Filter by occupation categories

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

Filter by regions or municipalities

## `publishedAt` (type: `string`):

Filter by publication date (e.g., 'last-24h', 'last-week', 'last-month')

## `employmentTypes` (type: `array`):

Filter by employment type

## `workExtent` (type: `string`):

Filter by work extent

## `drivingLicenseRequired` (type: `boolean`):

Filter jobs requiring driving license

## `unspecifiedSwedenWorkplace` (type: `boolean`):

Include jobs with unspecified workplace in Sweden

## `remote` (type: `boolean`):

Filter for remote work opportunities

## `openForAll` (type: `boolean`):

Jobs open for all applicants

## `abroad` (type: `boolean`):

Include jobs abroad

## `requiresExperience` (type: `boolean`):

Set to false to only show jobs that don't require experience

## `sort_by` (type: `string`):

Sort results by relevance or date

## `results_limit` (type: `integer`):

Maximum number of results to fetch

## `deepSearch` (type: `boolean`):

Fetch detailed information for each job (slower but more comprehensive)

## Actor input object example

```json
{
  "search_term": "utvecklare",
  "drivingLicenseRequired": false,
  "unspecifiedSwedenWorkplace": false,
  "remote": false,
  "openForAll": false,
  "abroad": false,
  "requiresExperience": true,
  "sort_by": "relevance",
  "results_limit": 10,
  "deepSearch": false
}
```

# 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("clack/arbetsformedlingen-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 = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clack/arbetsformedlingen-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/niDzksl8lc646ttzZ/builds/ERSXsLq0qE6vts7SO/openapi.json