# Blocket.se Car Scraper - Sweden Used Car Listings (`rastriq/blocket-scraper`) Actor

Scrape car listings from Blocket.se, Sweden's largest classifieds site: make, model, year, mileage in km, price in SEK, fuel, gearbox, city and dealer/private flag. Fast HTTP scraper, no browser.

- **URL**: https://apify.com/rastriq/blocket-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 car listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Blocket.se Car Scraper: Swedish used car listings to JSON, CSV or Excel

**Blocket.se Car Scraper** extracts car listings from [Blocket](https://www.blocket.se/mobility/search/car), Sweden's largest classifieds marketplace, with over 150,000 cars for sale at any time. Give it a search query such as `Volvo V60` or leave it empty to export listings from the whole car category. For every listing you get the make, model, model year, mileage in kilometres, asking price in SEK, fuel type, gearbox, city, whether the seller is a dealer or a private person, the main photo and the listing URL.

The scraper uses plain HTTP requests instead of a headless browser, so a run of a few hundred listings finishes in seconds, needs only 256 MB of memory and works with Apify's datacenter proxy. No residential proxy, no login and no cookies are required.

### What data does the Blocket scraper extract?

Each listing becomes one row in the dataset with these fields:

| Field | Description | Example |
|---|---|---|
| `id` | Blocket listing ID | `28227012` |
| `title` | Listing title as shown on Blocket | `Renault Clio` |
| `make` | Car make, taken from Blocket's structured data, so multi-word makes such as **Land Rover** or **Alfa Romeo** stay intact | `Renault` |
| `model` | Car model | `Clio` |
| `year` | Model year | `2001` |
| `km` | Mileage in kilometres. Blocket shows Swedish *mil* (1 mil = 10 km); the scraper converts it for you | `180950` |
| `price` | Asking price | `14900` |
| `currency` | Always `SEK` | `SEK` |
| `fuel_type` | Fuel, as published in Swedish: `Bensin`, `Diesel`, `El`, `Hybrid bensin`, `Plug-in Bensin`… | `Bensin` |
| `gearbox` | `Automatisk` or `Manuell`; empty when the card does not show it (common for electric cars) | `Manuell` |
| `city` | Location shown on the listing card | `Malmö` |
| `is_professional` | `true` for dealers and companies, `false` for private sellers | `false` |
| `img_url` | Main photo URL | `https://images.blocketcdn.se/...` |
| `url` | Link to the listing on blocket.se | `https://www.blocket.se/mobility/item/28227012` |
| `source` | Always `blocket_se` | `blocket_se` |
| `scraped_at` | Extraction time, ISO 8601 in UTC | `2026-11-14T07:15:48+00:00` |

Two more columns, `hp` (engine power) and `region` (county), are kept for compatibility with our other car marketplace scrapers. Blocket does not show them on search result cards, so `hp` is always `null` and `region` is always empty. The scraper does not open individual listing pages, and it never collects seller names, phone numbers or e-mail addresses.

### Use cases

- **Used car price monitoring in Sweden.** Track asking prices for a model over time and build depreciation curves by year and mileage.
- **Dealer and inventory intelligence.** Compare dealer stock against private sales with the `is_professional` flag, or see which makes and models dominate the market.
- **Car valuation and pricing models.** Feed thousands of real asking prices with year, mileage, fuel and gearbox into a valuation model or a price-check tool.
- **Lead lists for car buyers and importers.** Find underpriced listings for a given model and export them to a spreadsheet every morning.
- **Electric vehicle market research.** Filter by `fuel_type` = `El` or `Plug-in Bensin` to follow EV supply and prices in Sweden.
- **Cross-border comparison.** Combine with our scrapers for Finn.no, Mobile.de, Marktplaats, Leboncoin or Willhaben to compare the same model across European markets, which return the same column names.

### How to use the Blocket.se Car Scraper

1. Click **Try for free** and open the **Input** tab.
2. Type a **search query** (for example `Volvo`, `Tesla Model Y` or `Land Rover Defender`), or leave it empty to get cars from the whole category.
3. Set **Max listings** to the number of rows you need. It is also your cost cap.
4. Click **Start**. When the run finishes, open the **Output** tab and download the data as JSON, CSV, Excel or HTML, or read it through the Apify API.

You can schedule the actor to run every day and connect it to Google Sheets, Make, Zapier, n8n or a webhook through Apify integrations.

### Input example

```json
{
  "searchQuery": "Volvo",
  "maxItems": 50,
  "maxPages": 1,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

| Input | What it does | Default |
|---|---|---|
| `searchQuery` | Free-text search, the same as the Blocket search box | empty (all cars) |
| `make` | Advanced: a Blocket `variant` filter code copied from a Blocket URL (for example `0.744` for Audi) | empty |
| `maxItems` | Maximum number of listings to save | 100 |
| `maxPages` | Maximum number of result pages (50 listings per page) | 3 |
| `proxyConfiguration` | Apify proxy settings. Datacenter proxy is enough | Apify proxy |

The run stops at whichever comes first: `maxItems`, `maxPages`, or the last page of results. To export a large share of Blocket, raise both limits, for example `maxItems: 5000` and `maxPages: 100`.

### Output example

A real listing from a run on 14 November 2026:

```json
{
  "id": "28227012",
  "url": "https://www.blocket.se/mobility/item/28227012",
  "img_url": "https://images.blocketcdn.se/dynamic/default/item/28227012/b8f226f9-1fe0-412c-b605-20551935ba80",
  "title": "Renault Clio",
  "make": "Renault",
  "model": "Clio",
  "year": 2001,
  "km": 180950,
  "fuel_type": "Bensin",
  "gearbox": "Manuell",
  "price": 14900,
  "city": "Malmö",
  "is_professional": false,
  "hp": null,
  "currency": "SEK",
  "region": "",
  "source": "blocket_se",
  "scraped_at": "2026-11-14T07:15:48+00:00"
}
```

In the Apify Console the **Overview** view shows the main columns as a table, and the **Price and photo** view adds the listing thumbnail.

### How much does it cost to scrape Blocket?

The actor uses **pay-per-event** pricing, so you only pay for what you get:

- **$1.50 per 1,000 listings** saved to the dataset;
- **$0.005 per run start** (one start event per GB of memory; the default 256 MB counts as one).

Scraping 1,000 Swedish car listings costs about **$1.51**, and a quick test with 50 listings costs less than one cent. Platform usage (compute and datacenter proxy) is included in the price. Apify's free plan gives you monthly credit you can use to try it.

### Limits and good to know

- **Search result cards only.** Data comes from Blocket's search result pages, not from each listing's detail page. Fields that only exist on the detail page (equipment, description, VIN, colour, engine power) are not extracted.
- **50 listings per page.** Each page request returns up to 50 cars; the run waits briefly between pages to stay polite.
- **Values in Swedish.** `fuel_type` and `gearbox` are returned as Blocket publishes them (`Bensin`, `Automatisk`…). Mileage is the only value that is converted.
- **Seller-entered data.** Mileage and year are typed by sellers; a few listings contain obvious typos (for example an extra digit in the mileage). Filter outliers before modelling.
- **Empty searches fail loudly.** If Blocket returns no listings (for example a query with no matches, or the site layout changes) the run ends with a failed status and a clear message instead of an empty "successful" dataset.
- **Car category only.** The actor searches Blocket's car section (which also includes some light vans). Motorcycles, boats, caravans and non-vehicle classifieds are out of scope.

### FAQ

**Do I need a Blocket account or cookies?**
No. The scraper reads the public search pages that anyone can see without logging in.

**Do I need a residential proxy?**
No. Apify's datacenter proxy works for Blocket and keeps the cost low. Residential proxy would only add cost.

**How do I scrape a specific make or model?**
Use the search query: `Volvo XC60`, `Kia EV6` or `Mercedes-Benz Sprinter`. Results match Blocket's own search box. Advanced users can paste a Blocket `variant` make code into the `make` field.

**Why is `km` different from the number on Blocket?**
Blocket shows mileage in Swedish *mil*. One mil is 10 km, so `19 990 mil` becomes `199900` km in the dataset.

**How fresh is the data?**
Every run reads Blocket live, so you get the listings that are online at that moment, in Blocket's default order.

**Can I get seller contact details?**
No. The actor does not collect names, phone numbers or e-mail addresses, and it only tells you whether the seller is a dealer or a private person.

**Is scraping Blocket legal?**
The actor only reads publicly visible listing data and no personal data. You are responsible for how you use the data and for complying with Blocket's terms of use and with applicable law, including the GDPR. If in doubt, ask a lawyer.

**Something is broken or a field is missing. What should I do?**
Open an issue in the **Issues** tab with your run ID. Marketplace layouts change, and we fix scrapers quickly when they do.

# Changelog

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

# Actor input Schema

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

Free-text search, exactly as typed in the Blocket search box (for example `Volvo V60`, `Tesla Model Y` or `Land Rover Defender`). Leave empty to scrape the whole car category, newest listings first.

## `make` (type: `string`):

Optional Blocket `variant` filter code, copied from the `variant=` parameter of a Blocket search URL after selecting a make (for example `0.744` is Audi). Most users should use the search query instead.

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

Stop after this many listings. Each search page holds up to 50 listings. You pay per listing, so this is also your cost cap.

## `maxPages` (type: `integer`):

Maximum number of result pages to read (50 listings per page). The run stops at whichever limit is reached first, or when Blocket has no more results.

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

Apify datacenter proxy works for Blocket. Residential proxy is not needed and only adds cost.

## Actor input object example

```json
{
  "searchQuery": "Volvo",
  "maxItems": 50,
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `allFields` (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 = {
    "searchQuery": "Volvo",
    "maxItems": 50,
    "maxPages": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/blocket-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 = {
    "searchQuery": "Volvo",
    "maxItems": 50,
    "maxPages": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/blocket-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 '{
  "searchQuery": "Volvo",
  "maxItems": 50,
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/blocket-scraper --silent --output-dataset

```

## MCP server setup

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