# Blocket Cars Search Scraper (`stealth_mode/blocket-cars-search-scraper`) Actor

Scrape car listings from Blocket.se — Sweden's largest marketplace — and extract 30+ fields including make, model, price, mileage, fuel type, transmission, registration number, and location. Perfect for dealers, analysts, and automotive researchers.

- **URL**: https://apify.com/stealth\_mode/blocket-cars-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Blocket.se Cars Scraper: Extract Swedish Car Listings at Scale

---

### What Is Blocket.se?

Blocket.se is Sweden's most popular classifieds platform, with its automotive section hosting tens of thousands of used and new car listings from both private sellers and dealerships. Manually collecting pricing, mileage, or vehicle specs across hundreds of listings is impractical. The **Blocket.se Cars Scraper** automates this, turning search result pages into clean, structured datasets ready for analysis.

---

### Overview

The **Blocket Cars Scraper** targets Blocket's car search pages and extracts comprehensive listing data for each vehicle. It suits:

- **Car dealers** monitoring competitor pricing and inventory
- **Automotive analysts** tracking market trends by make, model, or region
- **Data aggregators** building used-car price indices
- **Researchers** studying the Swedish automotive resale market

The scraper supports multiple search URLs simultaneously, respects configurable item limits, and continues gracefully past failed URLs.

---

### Input Format

```json
{
  "urls": [
    "https://www.blocket.se/mobility/search/car?sort=MILEAGE_ASC&variant=1.757.2530"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 50
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `urls` | `array` | — | One or more Blocket car search page URLs to scrape. Supports bulk entry. Example: filter by brand, region, price, or sort order using Blocket's native search filters before copying the URL. |
| `ignore_url_failures` | `boolean` | `true` | If `true`, the scraper continues running when a URL fails instead of stopping the entire run. Recommended for bulk jobs. |
| `max_items_per_url` | `integer` | `20` | Maximum number of listings to collect per URL. Increase for broader market coverage, decrease for quick sampling. |

> **Tip:** Build your target search on Blocket.se first — apply filters for make, year range, region, or fuel type — then paste the resulting URL. The scraper will honour those filters.

***

### Output Format

**Sample output**

```json
{
  "type": "motor",
  "id": "20811148",
  "main_search_key": "SEARCH_ID_CAR_USED",
  "heading": "Citroen C3",
  "location": "Visby",
  "image": {
    "url": "https://images.blocketcdn.se/dynamic/default/item/20811148/0aa0ff0d-b4ff-4328-b0ed-51769384e067",
    "path": "item/20811148/0aa0ff0d-b4ff-4328-b0ed-51769384e067",
    "height": 3000,
    "width": 4000,
    "aspect_ratio": 1.3333333333333333
  },
  "flags": [],
  "timestamp": 1776254289000,
  "coordinates": {
    "lat": 57.59437,
    "lon": 18.52973,
    "accuracy": 5
  },
  "ad_type": 20,
  "labels": [],
  "canonical_url": "https://www.blocket.se/mobility/item/20811148",
  "extras": [],
  "price": {
    "amount": 11000,
    "currency_code": "SEK",
    "price_unit": "kr"
  },
  "year": 2006,
  "mileage": 312300,
  "mileage_unit": "SCANDINAVIAN_MILE",
  "dealer_segment": "Privat",
  "service_documents": [],
  "regno": "XWN111",
  "make": "Citroen",
  "series": "C3-Serie",
  "model": "C3",
  "model_specification": "1.6 HDi FAP Manuell",
  "transmission": "Manuell",
  "fuel": "Diesel",
  "registration_class": {
    "id": 1,
    "value": "Personbil"
  },
  "facade_title": "Citroen C3",
  "chassis_number": "VF7FC9HZC28682867",
  "sales_form": 1,
  "used_car_of_the_year": [],
  "ad_id": 20811148
}
```

Each listing returns a record with 30+ fields:

#### Identification

| Field | Meaning |
|---|---|
| `ID` | Internal Blocket listing identifier |
| `Ad ID` | Public-facing ad number |
| `Main Search Key` | Primary search index key used by Blocket |
| `Canonical URL` | Permanent URL to the individual listing |
| `Registration Number` | Swedish vehicle registration plate |
| `Chassis Number` | VIN / chassis identifier |

#### Listing Metadata

| Field | Meaning |
|---|---|
| `Type` | Record type (e.g., `car`) |
| `Ad Type` | Listing category (e.g., private sale, dealer) |
| `Heading` | Full listing title as displayed |
| `Facade Title` | Short display title used in search results |
| `Timestamp` | Date and time the listing was published or last updated |
| `Flags` | Special markers on the listing (e.g., price drop, new arrival) |
| `Labels` | Badges shown on the listing card |
| `Extras` | Additional listing metadata not covered by standard fields |

#### Location

| Field | Meaning |
|---|---|
| `Location` | City or region of the seller |
| `Coordinates` | Latitude/longitude of the listing location |

#### Pricing & Sale

| Field | Meaning |
|---|---|
| `Price` | Listed asking price (in SEK) |
| `Sales Form` | How the car is sold (e.g., fixed price, bidding) |
| `Dealer Segment` | Whether the seller is a private individual or a dealership |

#### Vehicle Specifications

| Field | Meaning |
|---|---|
| `Make` | Manufacturer (e.g., Volvo, BMW, Toyota) |
| `Series` | Model series or line (e.g., 3-Series, V-Series) |
| `Model` | Specific model name (e.g., V60, 320i) |
| `Model Specification` | Trim or variant detail (e.g., R-Design, xDrive) |
| `Year` | Model year of the vehicle |
| `Mileage` | Distance driven by the vehicle |
| `Mileage Unit` | Unit of mileage measurement (typically `km`) |
| `Transmission` | Gearbox type (e.g., Manual, Automatic) |
| `Fuel` | Fuel type (e.g., Petrol, Diesel, Electric, Hybrid) |
| `Registration Class` | Swedish vehicle registration category |

#### Quality & Trust Signals

| Field | Meaning |
|---|---|
| `Service Documents` | Whether full service history documentation is available |
| `Used Car Of The Year` | Whether the vehicle carries this award designation |
| `Image` | URL of the primary listing photo |

***

### How to Use

1. **Build your search** — Go to Blocket.se cars, apply your filters (brand, region, price, fuel, etc.), then copy the full URL from your browser.
2. **Configure input** — Paste one or more URLs into the `urls` array. Set `max_items_per_url` based on how many listings you need.
3. **Run the scraper** — Start the actor. For large runs, keep `ignore_url_failures: true` to avoid interruptions.
4. **Export** — Download results as JSON, CSV, or Excel for use in spreadsheets, databases, or BI tools.

**Common issues:**

- Ensure URLs point to **search result pages**, not individual listing pages.
- Blocket search URLs include filter state — verify filters are correct before running.
- For nationwide data, run multiple regional URLs in one job.

***

### Use Cases & Business Value

- **Pricing intelligence:** Track average market prices by make/model/year across Sweden
- **Inventory monitoring:** Watch how long specific vehicles stay listed
- **Dealer benchmarking:** Compare dealer vs. private seller pricing for the same model
- **Mileage analysis:** Identify low-mileage vehicles matching specific criteria at scale

***

### Conclusion

The **Blocket.se Cars Scraper** gives automotive professionals and researchers direct access to one of Scandinavia's richest used-car datasets. With detailed vehicle specs, pricing, location, and trust signals across 30+ fields, it removes hours of manual work and delivers market-ready data on demand.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Cars list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.blocket.se/mobility/search/car?sort=MILEAGE_ASC&variant=1.757.2530"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.blocket.se/mobility/search/car?sort=MILEAGE_ASC&variant=1.757.2530"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/blocket-cars-search-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 = {
    "urls": ["https://www.blocket.se/mobility/search/car?sort=MILEAGE_ASC&variant=1.757.2530"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/blocket-cars-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.blocket.se/mobility/search/car?sort=MILEAGE_ASC&variant=1.757.2530"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/blocket-cars-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/blocket-cars-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Blocket Cars Search Scraper",
        "description": "Scrape car listings from Blocket.se — Sweden's largest marketplace — and extract 30+ fields including make, model, price, mileage, fuel type, transmission, registration number, and location. Perfect for dealers, analysts, and automotive researchers.",
        "version": "0.0",
        "x-build-id": "ZmUgjteYElXIKdnce"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~blocket-cars-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-blocket-cars-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/stealth_mode~blocket-cars-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-blocket-cars-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/stealth_mode~blocket-cars-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-blocket-cars-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "URLs of the Cars list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Cars list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```