# Blocket Scraper: Car Monitor (`redomic/blocket-se-scraper`) Actor

Blocket scraper: each run returns up to 2,500 Blocket Bil and Torget listings as flat rows with price, make, model, year, mileage, VIN, inspections and seller. Monitor mode adds new, changed and removed since last run.

- **URL**: https://apify.com/redomic/blocket-se-scraper.md
- **Developed by:** [Redomic](https://apify.com/redomic) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 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

## Blocket Scraper: Swedish Car and Marketplace Listings

Export listings from Blocket.se, Sweden's biggest marketplace, to a spreadsheet or an API. Search cars on Blocket Bil or anything on Torget, and each row gives you the price in SEK, make, model, year, mileage, fuel, gearbox, location, seller and photos. Run it on a schedule and you get only the new listings, price changes and sold items since the last run.

### Who uses it

- **Car dealers and flippers** who want every new Volvo under 150,000 SEK the moment it's listed, not after someone else has called the seller.
- **Dealers watching competitors.** Give it a dealer's Blocket page and track their stock and price cuts.
- **Analysts** pricing used cars by model, year and mileage across Sweden.

### What you get

A search for `volvo` on Blocket Bil, newest first, on 15 November 2026:

| Car | Price (SEK) | Year | Mileage (km) | Fuel | Gearbox | Location | Seller |
|---|---|---|---|---|---|---|---|
| Volvo XC70 | 68,500 | 2008 | 290,000 | Diesel | Automatisk | Falköping | Privat |
| Volvo V60 | 149,000 | 2023 | 38,800 | Diesel | Automatisk | Göteborg | Privat |
| Volvo V40 | 109,900 | 2018 | 173,700 | Bensin | Manuell | Halmstad | Företag |
| Volvo XC60 | 467,900 | 2024 | 87,000 | Plug-in Bensin | Automatisk | Rönninge | Företag |
| Volvo 940 | 19,000 | 1996 | 320,000 | Bensin | Manuell | Linköping | Privat |

Each row also has the listing URL, the posting time, how many days the ad has been up, the photos, the registration number and, for dealers, the dealer's name and ID. Fuel, gearbox and seller type come in Swedish, as Blocket shows them (Företag is a dealer, Privat a private seller). Mileage comes both in Swedish mil and in km.

Turn on `scrapeDetails` (or use `detail` mode) and you also get the description, body type, colour, horsepower, the last and next inspection dates, the number of owners and the equipment list.

### Three modes

| Mode | What you get | Good for |
|---|---|---|
| `search` (default) | Listings that match your keywords and filters | Price surveys, one-off exports |
| `detail` | Full pages for specific ads or IDs | Checking a shortlist |
| `monitor` | Only listings that are new, changed price or disappeared since the last run | Deal alerts, competitor tracking |

### Price

$1.20 per 1,000 listings. There's no start fee. In monitor mode you pay only for new and changed listings, so a quiet day costs nothing. 100 listings cost $0.12.

### How to run it

Used Volvos under 150,000 SEK from 2015 or later, in Stockholm:

```json
{
  "query": "volvo",
  "vertical": "car",
  "priceMax": 150000,
  "yearMin": 2015,
  "location": "Stockholm",
  "maxItems": 200
}
```

You can also paste a search URL from blocket.se into `startUrls` and keep the filters you set on the site.

Get a daily alert for new and cheaper cars. Save this as a task and schedule it every morning:

```json
{
  "mode": "monitor",
  "query": "volvo",
  "vertical": "car",
  "priceMax": 300000,
  "publishedWithinDays": 3,
  "maxItems": 500
}
```

The first run records what's listed today and returns it all as `new`. From then on you get only `new` ads, `changed` prices (with the old price and the difference) and `removed` ads.

To follow one dealer, put their Blocket dealer page in `startUrls` or their ID in `dealerOrgIds`.

### Big searches

Blocket shows at most 2,500 results for one search. With `partition` on (the default), the Actor splits a bigger search into price bands and collects past that limit. The run reports how many results Blocket had and how many you got.

### Input

| Field | Default | What it does |
|---|---|---|
| `mode` | `search` | `search`, `detail` or `monitor`. |
| `query` | `volvo` | A keyword. Use `queries` for several, each with its own `vertical`. |
| `vertical` | `car` | `car` (Blocket Bil), `torget` (the marketplace) or `all`. |
| `startUrls` | none | Blocket search, ad or dealer page URLs. |
| `dealerOrgIds` | none | Dealer IDs: the number in a dealer page URL. |
| `listingUrls`, `listingIds` | none | Specific ads for `detail` mode. Prefix Torget IDs with `torget:`. |
| `priceMin`, `priceMax` | none | Price range in SEK. |
| `priceType` | any | `fixed`, `auction` or `request`. |
| `yearMin`, `yearMax` | none | Model year range. |
| `mileageMin`, `mileageMax` | none | Mileage in mil (1 mil = 10 km). |
| `bodyType`, `fuel`, `transmission` | any | Blocket's own names, for example `Kombi`, `Diesel`, `Automatisk`. |
| `location` | all of Sweden | A region such as `Stockholm`, `Skåne` or `Västra Götaland`. |
| `dealerSegment` | any | `Företag` (dealer) or `Privat` (private). |
| `salesForm` | any | `Begagnad` (used), `Ny` (new) or `Leasing`. |
| `publishedWithinDays` | none | Only ads posted in the last N days. |
| `sort` | newest first | Blocket's sort orders. |
| `scrapeDetails` | `false` | Open each ad for the full details. Slower. |
| `onlyWithImages` | `false` | Skip ads without photos. |
| `shippingOnly` | `false` | Only ads that offer Blocket Frakt shipping. |
| `includeRemoved` | `true` | In monitor mode, report ads that disappeared. |
| `partition` | `true` | Collect past Blocket's 2,500-result limit. |
| `maxItems` | `100` | The most listings to return, up to 10,000. |

### Output fields

**Every row:** `id`, `url`, `title`, `vertical`, `make`, `model`, `year`, `mileage`, `mileageUnit`, `mileageKm`, `fuel`, `transmission`, `priceAmount`, `priceCurrency`, `priceType`, `location`, `sellerType`, `sellerName`, `sellerId`, `registrationNumber`, `postedAt`, `listingAgeDays`, `imageUrl`, `imagesCount`.

**With details:** `description`, `bodyType`, `color`, `powerHp`, `lastInspectionAt`, `nextInspectionAt`, `ownersCount`, `equipment`.

**Monitor mode:** `changeType`, `previousPriceAmount`, `priceDelta`, `firstSeenAt`.

Run status and per-source counts are saved as `STATUS` and `SUMMARY` records in the run key-value store. Market value is compared with the same make, model and model year (within one year), and with a similar mileage when enough comparable cars exist.

### FAQ

**Is there an official Blocket API?**
Not for searching listings. This Actor reads Blocket's public pages and turns them into rows.

**Why is `priceAmount` empty on some ads?**
The ad has no fixed price. `priceType` tells you whether it's an auction or price on request.

**Do I get seller phone numbers?**
No. You get the dealer's name and ID for business sellers. Private sellers stay anonymous.

**Does it work for Torget, not only cars?**
Yes. Set `vertical` to `torget` for the marketplace or `all` for both.

**Something looks wrong in my results.**
Open an issue on the Issues tab with your input and we'll look at it.

### På svenska

Exportera annonser från Blocket till ett kalkylark: pris, märke, modell, år, miltal, bränsle, växellåda, ort och säljare. Sök på Blocket Bil eller Torget. I läget `monitor` får du bara nya annonser, prisändringar och borttagna annonser sedan förra körningen.

### Use it from AI agents (MCP) and Python

**AI agents.** Add this Actor as a tool in Claude, Cursor, VS Code or any MCP client through the Apify MCP server. The agent reads the input schema, so a plain request is enough.

```json
{
  "mcpServers": {
    "blocket-se-scraper": {
      "url": "https://mcp.apify.com?tools=redomic/blocket-se-scraper",
      "headers": {
        "Authorization": "Bearer <YOUR_APIFY_TOKEN>"
      }
    }
  }
}
```

**Python.** `pip install apify-client`, then:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("redomic/blocket-se-scraper").call(run_input={"query": "volvo", "vertical": "car", "mode": "search", "maxItems": 25})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### More from us

- [Allabolag Scraper - Swedish Company Data](https://apify.com/redomic/allabolag-company-scraper): Scrape allabolag.se for Swedish company financials, industry, status and board role titles by search, org number or URL
- [Ashby Jobs Scraper with Salaries](https://apify.com/redomic/ashby-jobs-monitor): Ashby jobs scraper for any startup careers board (OpenAI, Ramp, Notion and thousands more), with salary ranges as numbers: min, max, currency, period, plus equity and bonus flags
- [ATS Jobs Search: Greenhouse, Lever & Ashby Jobs API](https://apify.com/redomic/ats-jobs-search): Search 300,000+ open jobs from 11,000+ companies on Greenhouse, Lever and Ashby in one run
- [Closed Jobs Tracker: Filled Roles & Time-to-Fill](https://apify.com/redomic/closed-jobs-tracker): Search closed jobs from 11,000+ companies with closedOn, daysOpen and time-to-fill signals
- [Google Jobs Scraper - Job Postings API](https://apify.com/redomic/google-jobs): Google Jobs and job postings scraper: get job title, company, location, posted date, salary, full description and every apply link for any search
- [Google Trends API: Trending Now & Interest Over Time](https://apify.com/redomic/google-trends): Trending-now searches and new-trends alerts/monitoring per country with the news behind them, plus interest over time, interest by region, and related and rising queries for any keyword
- [GovDeals Scraper](https://apify.com/redomic/govdeals-scraper): Search and monitor GovDeals government surplus auctions
- [Greenhouse Jobs Monitor & Scraper](https://apify.com/redomic/greenhouse-jobs-monitor): Monitor Greenhouse jobs from any company careers board (Airbnb, Stripe, Discord and thousands more)
- [Job Postings Dataset: 320k+ Open Jobs, Updated Daily](https://apify.com/redomic/job-postings-dataset): 320,000+ open jobs from 10,000+ company career sites (Greenhouse, Lever, Ashby), updated daily with first-seen and closed dates
- [Lever Jobs Scraper with Salaries](https://apify.com/redomic/lever-jobs-monitor): Lever jobs scraper for any company's careers page (Palantir, Spotify, Zoox, Shield AI and thousands more): flat rows with title, team, location, workplace, commitment, apply link, salary as numbers and the full description merged
- [Marktplaats.nl Scraper](https://apify.com/redomic/marktplaats-nl): Scrape Marktplaats.nl listings into clean rows: title, price in EUR, condition, seller, location, images
- [Otodom Scraper: Poland Property Listings & Price Monitor](https://apify.com/redomic/otodom-scraper): Scrape Otodom.pl property listings in Poland
- [Otomoto.pl Scraper](https://apify.com/redomic/otomoto-scraper): Scrape Otomoto.pl Polish car listings: one run returns used-car rows with price, make, model, year, mileage, fuel, gearbox, seller and URL
- [Personio Jobs Scraper](https://apify.com/redomic/personio-jobs): Scrape open jobs from Personio company career pages (jobs.personio.de/.com XML feeds)
- [Salary Data API: Pay Ranges by Job Title & Level](https://apify.com/redomic/salary-data): Get salary benchmarks (p10-p90, annualised, with n) and pay ranges from 150,000+ employer-posted jobs across 11,000+ companies, updated daily
- [SIRET Company Scraper](https://apify.com/redomic/siret-company-scraper): Search French companies by name, SIREN or SIRET
- [SUUMO Scraper - Japan Property Listings](https://apify.com/redomic/suumo-scraper): Scrape SUUMO Japan property listings from search URLs for rentals and sales
- [Talabat Scraper — Menus, Prices & Delivery Fees](https://apify.com/redomic/talabat-scraper): Talabat menus, prices and delivery fees as flat rows in 8 MENA markets
- [Workday Jobs Scraper](https://apify.com/redomic/workday-jobs): Search and monitor public Workday (myworkdayjobs.com) job postings

# Changelog

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

# Actor input Schema

## `mode` (type: `string`):

search = listings, detail = full pages for specific ads, monitor = new/changed/removed since last run.

## `queries` (type: `array`):

Keyword searches. Each item can set its own vertical (car, torget or all).

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

Single keyword (used when queries is empty).

## `vertical` (type: `string`):

car = Blocket Bil cars, torget = Torget marketplace, all = both.

## `startUrls` (type: `array`):

Past Blocket search, ad or dealer page URLs (a dealer page, e.g. https://www.blocket.se/mobility/dealer/7903992/riddermark-bil-goteborg, returns that dealer's whole car inventory).

## `dealerOrgIds` (type: `array`):

Blocket dealer IDs (the number in a dealer page URL, also the sellerId on business rows). Each returns that dealer's full car inventory; use monitor mode to track what a competitor adds, reprices and sells.

## `listingUrls` (type: `array`):

Specific ad URLs to fetch in detail (also used with mode search/monitor).

## `listingIds` (type: `array`):

Blocket ad IDs, e.g. 26371427. Prefix with torget: for Torget ads, e.g. torget:28099024. Unprefixed IDs are car ads.

## `priceMin` (type: `integer`):

Keep listings priced at or above this value.

## `priceMax` (type: `integer`):

Keep listings priced at or below this value.

## `priceType` (type: `array`):

Keep only listings with these price types: fixed (priced), auction, or request (price on request/free). Empty = all.

## `yearMin` (type: `integer`):

Keep cars with model year at or after this value.

## `yearMax` (type: `integer`):

Keep cars with model year at or before this value.

## `publishedWithinDays` (type: `integer`):

Keep only listings published within the last N days (applied to postedAt, e.g. 1, 3, 7 or 9).

## `mileageMin` (type: `integer`):

Keep cars with mileage at or above this value, in mil (Swedish miles, 1 mil = 10 km; e.g. 2000 mil = 20,000 km).

## `mileageMax` (type: `integer`):

Keep cars with mileage at or below this value, in mil (Swedish miles, 1 mil = 10 km; e.g. 2000 mil = 20,000 km).

## `bodyType` (type: `string`):

Kombi, Sedan, SUV, Halvkombi 5-dörrar, Halvkombi 3-dörrar, Familjebuss, Coupé, Cabriolet, Pickup, Skåpbil or Annat - or the numeric code Blocket shows in URLs (e.g. Kombi = 4).

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

Swedish region name (e.g. Stockholm, Skåne, Västra Götaland) or Blocket region/city code (e.g. 0.300001 for Stockholm län, 1.300001.310180 for Stockholm kommun).

## `fuel` (type: `string`):

Bensin, Diesel, El, Hybrid bensin, Hybrid diesel, Plugin bensin, Plugin diesel, Etanol, Fordonsgas, Vätgas - or the numeric code Blocket shows in URLs.

## `transmission` (type: `string`):

Manuell, Automatisk or Sekventiell - or the numeric code.

## `dealerSegment` (type: `string`):

Företag (company/dealer) or Privat (private) - or the numeric code.

## `salesForm` (type: `string`):

Begagnad (used), Ny (new) or Leasing - or the numeric code.

## `sort` (type: `string`):

Sort order for results.

## `scrapeDetails` (type: `boolean`):

Fetch each listing page in search mode for full specs (inspection dates, equipment). Slower; monitor mode stays list-only. While off, detail-only fields are omitted from rows entirely (no blank CSV columns).

## `compareToMarket` (type: `boolean`):

Add in-run below-market valuation (no extra requests): marketValue is the median price of at least 5 priced listings with the same make and model in this run, with priceVsMarketSek, priceVsMarketPct, marketComparables, marketConfidence and redFlags on each row.

## `onlyBelowMarketPct` (type: `number`):

Keep only rows priced at least this many percent below marketValue (e.g. 10 keeps rows at -10% or cheaper). Rows without a market comparison are dropped while this filter is set. Red-flagged rows are dropped unless includeRedFlagged is true.

## `onlyBelowMarketSek` (type: `integer`):

Keep only rows priced at least this many SEK below marketValue. Rows without a market comparison are dropped while this filter is set. Red-flagged rows are dropped unless includeRedFlagged is true.

## `includeRedFlagged` (type: `boolean`):

When a below-market filter is set, red-flagged rows (motorfel, växellådsfel, körförbud, startar ej, krockskadad, reservdelar, or priced under 35% of market) are dropped unless this is true. Unfiltered runs always return them with redFlags set.

## `partition` (type: `boolean`):

When a search hits Blocket's 2,500-per-query ceiling and maxItems asks for more, automatically split the query into price bands (recursively halved to a 2,000-match safe cap per band), collect and dedupe by ad ID, and report partitions plus expected-vs-collected in the status row. Default true; set false to keep the old stop-at-2,500 behaviour.

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

Upper limit on rows returned per run. 2,500 is Blocket's per-query ceiling; with partition true the run can collect beyond it up to this limit.

## `includeRemoved` (type: `boolean`):

In monitor mode, include listings that disappeared since the previous run as removed rows. Set false to report only new and changed listings; state still tracks removals so nothing is re-reported later.

## `proxy` (type: `object`):

Proxy settings.

## `onlyWithImages` (type: `boolean`):

Keep only listings that have at least one photo (imagesCount > 0).

## `shippingOnly` (type: `boolean`):

Keep only listings where the seller offers Blocket Frakt (shipping).

## Actor input object example

```json
{
  "mode": "search",
  "query": "volvo",
  "vertical": "car",
  "sort": "published_desc",
  "scrapeDetails": false,
  "compareToMarket": true,
  "includeRedFlagged": false,
  "partition": true,
  "maxItems": 100,
  "includeRemoved": true,
  "proxy": {
    "useApifyProxy": true
  },
  "onlyWithImages": false,
  "shippingOnly": false
}
```

# Actor output Schema

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

All result rows from the default dataset.

# 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 = {
    "mode": "search",
    "query": "volvo",
    "vertical": "car",
    "sort": "published_desc",
    "compareToMarket": true,
    "partition": true,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("redomic/blocket-se-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 = {
    "mode": "search",
    "query": "volvo",
    "vertical": "car",
    "sort": "published_desc",
    "compareToMarket": True,
    "partition": True,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("redomic/blocket-se-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 '{
  "mode": "search",
  "query": "volvo",
  "vertical": "car",
  "sort": "published_desc",
  "compareToMarket": true,
  "partition": true,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call redomic/blocket-se-scraper --silent --output-dataset

```

## MCP server setup

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