# Academic Work Scraper — Sweden Job Listings (`studio-amba/academic-work-scraper`) Actor

Scrape job listings from Academic Work, Sweden's largest staffing and recruitment agency for students and young professionals. Titles, cities, employment type and posting dates. No login or cookies required.

- **URL**: https://apify.com/studio-amba/academic-work-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

## Academic Work Scraper

Extract job listings from [Academic Work](https://www.academicwork.se), Sweden's largest staffing and recruitment agency for students and young professionals, as clean structured JSON. Get job titles, cities, employment type, assignment type, client company (when disclosed) and posting dates in one run.

No login. No cookies. No browser automation. The actor reads the same server-rendered job data Academic Work's own site fetches when you page through its listing, so it is fast and stable.

### What this actor does

This actor crawls the full live Academic Work Sweden job catalogue (typically 400-500 active listings) and returns one row per job with:

- Job title
- Hiring agency (Academic Work) and end client, when disclosed
- City
- Employment type (full-time / part-time)
- Assignment type (staffing/consultant assignment vs. direct recruitment)
- Posting date, both as an ISO timestamp and the site's original relative text
- Business-area category
- The job's unique ID and direct URL

Academic Work places staff for hundreds of Swedish employers across IT, engineering, economy, sales, HR and logistics. Roughly a third of listings name the actual hiring client (e.g. "Fouredge AB", "Ragn-Sells Recycling AB") rather than just Academic Work itself — this actor captures that client name whenever the site discloses it.

### Why use it

- **Staffing market research** — track what roles Sweden's largest staffing agency is placing, for whom, and where.
- **Recruitment and sourcing** — build a live feed of consultant and direct-hire positions for a role or region.
- **Client intelligence** — see which Swedish companies are actively hiring through Academic Work right now.
- **Aggregators and job boards** — feed Swedish staffing-agency listings into your own product.

### How to scrape Academic Work data

1. Open the actor. All fields are optional — leave everything blank to scrape the full live catalogue.
2. Optionally set a **Search Query** to filter job titles by keyword (e.g. `marknad`, `ekonomi`, `IT-support`).
3. Optionally set a **Location filter** for a Swedish city (e.g. `Stockholm`, `Göteborg`, `Malmö`).
4. Set **Max Results** — the actor paginates the live listing (10 jobs per request) until this cap is reached or the catalogue runs out.
5. Leave the proxy on the default automatic setting and click **Start**.

The actor calls Academic Work's own pagination endpoint page by page, decodes each page's job data, applies your filters client-side, and writes everything to the dataset. Export the result as JSON, CSV or Excel.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Optional keyword to filter job titles by. Applied client-side — the listing has no working server-side keyword search. |
| `location` | string | Optional Swedish city filter, applied client-side. |
| `maxResults` | integer | Maximum number of job listings to return (up to 1000). Default: `100`. |
| `proxyConfiguration` | object | Apify proxy settings. Default: automatic (no anti-bot on this site). |

#### Example input

```json
{
    "searchQuery": "",
    "location": "Stockholm",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

### Output

Each dataset item looks like this:

```json
{
    "title": "Nätverkstekniker till Fouredge",
    "company": "Academic Work",
    "clientCompany": "Fouredge AB",
    "locationRaw": "Hammarby Sjöstad",
    "locationParsed": { "city": "Hammarby Sjöstad", "country": "Sweden" },
    "language": "sv",
    "postedAt": "2026-09-01T11:19:21.993Z",
    "postedAtRaw": "för 3 timmar sedan",
    "descriptionSnippet": "",
    "url": "https://www.academicwork.se/lediga-jobb/j/natverkstekniker-till-fouredge/RU69DO",
    "employmentType": "Heltid",
    "assignmentType": "Rekrytering",
    "source": "academicwork.se",
    "scrapedAt": "2026-09-01T14:19:21.993Z",
    "jobId": "RU69DO"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title |
| `company` | string | Hiring agency — always `Academic Work` |
| `clientCompany` | string | Academic Work's end client, when disclosed on the listing (~1 in 3 jobs) |
| `locationRaw` | string | City as shown on the listing |
| `locationParsed` | object | `{ city, country }` |
| `language` | string | ISO 639-1 language code (`sv`) |
| `postedAt` | string | ISO 8601 posting timestamp, derived from the site's relative time text |
| `postedAtRaw` | string | Original relative-time text (e.g. `för 2 timmar sedan`, `Idag`) |
| `descriptionSnippet` | string | Not exposed in the listing view — always empty (full descriptions are only on the per-job detail page) |
| `url` | string | Full job listing URL |
| `employmentType` | string | `Heltid` (full-time) or `Deltid` (part-time), when shown |
| `assignmentType` | string | `Konsultuppdrag` (staffing/consultant assignment) or `Rekrytering` (direct recruitment), when shown |
| `category` | string | Business-area icon slug (e.g. `system_developer`, `support`, `construction`) — only present when the listing shows a generic category icon rather than a client logo |
| `salaryRaw` | string | Not disclosed in the listing view — always empty |
| `source` | string | Source site identifier (`academicwork.se`) |
| `scrapedAt` | string | ISO 8601 timestamp of collection |
| `jobId` | string | Unique Academic Work job identifier |

### Cost estimate

This actor makes one lightweight HTTP request per 10 jobs — no browser, no per-item detail fetches. A full-catalogue run (~430 jobs) makes roughly 43 requests and finishes in under a minute. Usage is only charged after a run finishes with status SUCCEEDED — a failed or aborted run doesn't bill for partial results.

### Limitations

- **Listing data only.** `descriptionSnippet` and `salaryRaw` are always empty — Academic Work doesn't expose a description excerpt or salary in the listing view, only on each job's own detail page, which this actor doesn't fetch (keeps the crawl to one request per 10 jobs instead of one per job).
- **Client company is only ~1 in 3 jobs.** Academic Work shows a generic business-area icon for the rest; `clientCompany` and `category` are mutually exclusive per listing.
- **Search and location filters are client-side.** Academic Work's listing page has no working server-side keyword search; both filters are applied by substring match after fetching.
- **Swedish only.** Academic Work Sweden posts in Swedish (with occasional English-language listings for international roles); this actor covers the Swedish site only.

### Related scrapers

Building a Nordic or European staffing dataset? These sibling actors follow the same clean-JSON approach:

- **Arbetsförmedlingen Scraper** — Sweden's public employment service
- **Manpower Scraper** — multi-country staffing agency jobs
- **Adecco Scraper** — multi-country staffing agency jobs
- **Randstad Scraper** — Belgian staffing agency jobs
- **Hays Scraper** — UK jobs and salary data

### Disclaimer

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

# Actor input Schema

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

Optional keyword to filter job titles by (e.g. 'marknad', 'ekonomi', 'IT-support'). Applied client-side after fetching — Academic Work's listing page has no working server-side keyword search. Leave empty to scrape the full live catalogue.

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

Optional Swedish city to filter results by (e.g. 'Stockholm', 'Göteborg', 'Malmö'). Applied client-side after fetching.

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

Maximum number of job listings to return. Academic Work typically lists 400-500 active jobs across Sweden; the actor paginates the live listing until this cap is reached or the catalogue runs out.

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

Proxy settings. Automatic Apify Proxy works reliably — Academic Work's listing page has no anti-bot protection (verified live).

## 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/academic-work-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/academic-work-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/academic-work-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/academic-work-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/8wErdb3RYwYDc3Vz5/builds/RNhOnw5qzDOWv1d73/openapi.json