How to Scrape Blocket.se Swedish Classifieds in 2026

Blocket.se is Sweden’s dominant classifieds marketplace — over a million live listings spanning used cars, electronics, furniture, boats and second-hand goods. For anyone doing Swedish price intelligence, used-car analytics, or reseller arbitrage, it’s the single richest source in the country. Unlike a server-rendered classifieds site, Blocket runs a modern React front-end backed by internal JSON search APIs, which is actually good news: you can hit those APIs directly and skip browser rendering entirely. This guide covers how Blocket exposes its data and how to extract it cleanly at volume in 2026.

What’s worth extracting

Blocket splits its inventory across two internal API surfaces — recommerce for general marketplace items and mobility for vehicles — which means the field set differs by category. Per listing you can pull:

• Identity — listing ID and canonical URL, headline.
• Price — the formatted price string with currency (SEK).
• Location — region/municipality plus GPS coordinates.
• Seller — name and seller classification (private vs business), which matters enormously for dealer-vs-private analysis.
• Shipping — whether the item is shippable (Blocket’s frakt/shipping flag), useful for filtering arbitrage candidates.
• Images — image URLs.
• Transaction type — sale type / listing category.
• Publication timestamp.

For vehicle listings specifically, you also get the full automotive attribute set:

• Brand/make, model and trim, model year.
• Odometer reading in Swedish mil (1 mil = 10 km — a Sweden-specific unit that trips up everyone the first time).
• Fuel type, transmission, and registration number.

The vehicle attributes plus seller classification are what make Blocket valuable for used-car analytics: you can chart price by make/model/year and separate dealer pricing from private-seller pricing.

How the data is exposed

Blocket is API-backed, which shapes the whole approach:

• Two internal search APIs. The React front-end calls recommerce (marketplace) and mobility (vehicles) JSON endpoints. The actor auto-selects the right one based on whether the category is a vehicle category — and that auto-selection matters because the response schemas differ.
• No browser rendering needed. Because the data comes from JSON APIs rather than the rendered DOM, native HTTP fetch is enough — no Playwright, no headless Chrome. That keeps it fast and cheap.
• Pagination with delay. You page through results with an inter-page delay to stay polite, and the actor dedups listings by ID in-memory so you don’t get the same item twice across pages.
• Proxy rotation for volume. For high-volume runs, proxy rotation spreads requests so you don’t hit per-IP throttling on the internal APIs.

The practical realities:

1. Two schemas. Marketplace items and vehicles return different field sets. Your pipeline has to handle both and not assume vehicle fields exist on a sofa listing.
2. The mil trap. Odometer is in Swedish mil. Multiply by 10 for kilometers, or your “low-mileage” filter will be off by an order of magnitude.
3. Seller classification is gold but inconsistent. Private vs business is exposed, but you’ll want to sanity-check it against seller behavior for dealer-monitoring use cases.
4. Internal APIs can change. They’re not a published contract, so the response shape can shift without notice — the standard cost of API-backed scraping.

URL and API structure

Blocket’s public URLs are category-segmented; behind them the front-end calls the internal search APIs:

# Public category browse (marketplace, e.g. electronics in a region)
https://www.blocket.se/annonser/hela_sverige/elektronik?...

# Vehicles (cars) browse
https://www.blocket.se/bilar/sok?...

# Behind these, internal JSON search APIs:
#   recommerce  -> marketplace items
#   mobility    -> vehicles (cars, motorcycles, boats)

The actor maps your category and region to the correct internal endpoint, paginates, and emits one normalized row per listing.

▶ Run the Blocket.se Scraper — cars, electronics and marketplace items with prices, images, coordinates, seller type and full vehicle attributes. No browser, JSON-API backed. Pay per result.

Build it yourself vs. use a managed actor

Because it’s API-backed, a one-off marketplace pull is doable — but the dual-schema vehicle handling and the volume plumbing add up:

• Building from scratch — reverse-engineer both the recommerce and mobility API shapes, write the auto-selection logic, normalize two schemas (including the mil-to-km conversion and seller classification), handle pagination with dedup, and add proxy rotation for volume. Plan on a few days, plus re-fixing when the internal API shifts.
• Using a managed actor — set category and Swedish region, run, get normalized rows with vehicle attributes already parsed and the right endpoint auto-selected.

The deciding factor is usually the vehicle schema plus the proxy/dedup plumbing for volume. For a one-time small marketplace pull you could DIY; for a recurring used-car analytics feed across regions, the normalization and rotation are the parts worth not maintaining.

Schema design for downstream use

A unified per-listing row that handles both marketplace and vehicle categories:

{
  "listing_id": "1402938471",
  "url": "https://www.blocket.se/annons/...",
  "headline": "Volvo V60 D4 Momentum 2018",
  "price": 184900,
  "currency": "SEK",
  "region": "Västra Götaland",
  "municipality": "Göteborg",
  "lat": 57.7089,
  "lon": 11.9746,
  "seller_type": "business",
  "seller_name": "Bilcenter AB",
  "shippable": false,
  "image_urls": ["https://...", "https://..."],
  "category": "cars",
  "vehicle": {
    "make": "Volvo",
    "model": "V60 D4 Momentum",
    "year": 2018,
    "odometer_km": 89000,
    "fuel": "diesel",
    "transmission": "automatic",
    "registration": "ABC123"
  },
  "published_at": "2026-06-02T10:15:00Z",
  "scraped_at": "2026-06-03T08:00:00Z"
}

Schema choices worth making:

• Convert mil to kilometers on ingest and store odometer_km — never leave the raw mil value to confuse downstream consumers.
• Keep the vehicle block nested and null for non-vehicle listings so marketplace items and cars share one table cleanly.
• Always store seller_type. Dealer-vs-private is the central axis for pricing analytics and competitor monitoring.
• Capture lat/lon. Geo enables regional arbitrage detection (same item, different region, different price).

Typical use cases

• Vehicle dealers — monitor the used-car market, track competitor pricing, source inventory.
• Price intelligence — for resellers and buyers across categories.
• Market research — supply/demand analysis in the Swedish classifieds market.
• Deal hunting — keyword and category searches across Sweden to find specific items.
• Business intelligence — track dealer-vs-private pricing and inventory trends over time.
• Geo-analysis — map listings by coordinates and price.
• Reseller arbitrage — compare identical items across regions to find buy-low/sell-high gaps.
• Electronics monitoring — model-specific price tracking and volume alerts.
• Vintage/furniture sourcing — including detection of shippable items via the shipping flag.

Cost math

The result event is priced at zero — you pay only the negligible per-run start fee plus Apify compute. Since Blocket is JSON-API-backed with no browser, compute stays low even on large runs. A recurring used-car analytics feed pulling several regions daily costs little more than the run minutes. Add proxy bandwidth only when you push genuinely high volume. Versus building and maintaining the dual-schema parser and proxy rotation yourself, the managed route is the cheaper path to a reliable Swedish classifieds feed.

Common pitfalls

• The mil unit. Swedish odometers are in mil (×10 for km). Forget this and every mileage filter and analytics number is wrong by 10×.
• Assuming vehicle fields everywhere. A furniture listing has no fuel type. Branch on category; don’t blindly read vehicle keys.
• Internal API drift. The recommerce/mobility endpoints aren’t a public contract — expect occasional shape changes and parse defensively.
• Duplicate listings across pages. Dedup on listing_id, not URL, since the same item can surface on multiple result pages.
• Region scoping. “Hela Sverige” (all Sweden) is huge — scope by region for targeted, manageable runs.
• Price as a formatted string. Blocket prices come formatted ("184 900 kr"); parse to a numeric SEK value before doing math.

Wrapping up

Blocket.se is API-backed rather than DOM-rendered, so the smart approach skips the browser and hits its recommerce and mobility JSON endpoints directly. The real work is the dual-schema normalization — handling marketplace items and vehicles in one pipeline, converting Swedish mil to kilometers, classifying sellers, and adding dedup and proxy rotation for volume. If you need a small one-off pull you can build it; if you want a recurring, regionally-scoped Swedish classifieds feed for used-car analytics or arbitrage, a managed actor that already handles the two schemas and the volume plumbing is the cleaner path.

▶ Open the Blocket.se Scraper on Apify — Swedish classifieds and used cars with full vehicle attributes, coordinates and seller type. No browser. Pay per result, start on Apify’s free monthly credit.