# Blocket.se Classifieds Search & Price Filter Tool (`vexaloom-labs/blocket-se-classifieds-search-and-price-filter`) Actor

Search Blocket.se by keyword across all categories, cars, electronics, or furniture, with a price range filter in SEK, and location, condition, and seller details per listing.

- **URL**: https://apify.com/vexaloom-labs/blocket-se-classifieds-search-and-price-filter.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** E-commerce, Automation, Real estate
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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.se Classifieds Search & Price Filter Tool

Blocket.se is Sweden's largest second-hand marketplace: cars, electronics, furniture, tools and almost everything else. This actor searches its public listings by keyword, narrows results with real Blocket filters, follows pagination until your item limit, and can open individual ads for the full description, condition, category and seller details.

Everything runs cookieless. No Blocket account, login, cookie or proxy setup is needed.

### What this actor does

- Searches Blocket by keyword across all categories, or restricts the search to cars, electronics or furniture.
- Applies Blocket's own filters: price range in SEK, condition, private or company seller, ad type, Swedish county, publication date, sort order, and car-specific year, mileage, fuel, gearbox and body type.
- Walks the result pages until `maxItems` is reached, removes duplicate ads, and stops at Blocket's own pagination ceiling.
- Fetches full ad details by URL or ad ID, including description, category path, condition, specifications and public seller contact data.
- Optionally enriches every search result with the full ad page (`includeDetails`).
- Leaves a field out whenever Blocket does not publish it for that ad instead of emitting `null` or a fake value.

### Output per listing

Core fields:

| Field | Description |
|---|---|
| `adId` | Blocket ad ID |
| `title` | Listing headline |
| `price` | Asking price in SEK |
| `currency` | Currency code, normally `SEK` |
| `priceExVat` | Price excluding VAT when the seller publishes it (mostly cars) |
| `location` | City or locality |
| `postalCode` | Postal code when the ad page publishes it |
| `category` | Category path, e.g. `Elektronik och vitvaror > Datorer > Laptops` |
| `condition` | Stated condition, e.g. `Bra skick - varsamt använd` |
| `publishedDate` | Publication time (ISO 8601) |
| `imageUrl` | Main image URL |
| `imageUrls` | All image URLs when more than one is published |
| `adUrl` | Direct link to the ad |
| `seller` | Seller or shop name when Blocket publishes it |
| `sellerType` | `Privat` or `Företag` |
| `sellerCity`, `sellerZip` | Shop address locality and postal code |
| `sellerPhone`, `sellerProfileUrl` | Public shop phone number and profile link |
| `brand` | Brand when the listing states one |
| `tradeType` | `Säljes`, `Bortskänkes` or `Köpes` |
| `latitude`, `longitude` | Ad coordinates when published |
| `shippingAvailable`, `buyNow` | Blocket shipping and Buy Now flags |
| `description` | Full ad text (details mode or `includeDetails`) |
| `specifications` | All ad attributes published on the page, as label/value pairs |
| `mode` | Mode that produced the record |
| `scrapedAt` | UTC timestamp of the scrape |

Car listings add:

| Field | Description |
|---|---|
| `make`, `model`, `modelSpecification`, `series` | Vehicle identity |
| `year` | Model year |
| `mileage`, `mileageUnit`, `mileageKm` | Published mileage, its unit, and the same value in kilometres |
| `fuel`, `transmission` | Powertrain and gearbox |
| `registrationNumber`, `vin` | Registration plate and chassis number |
| `registrationClass`, `salesForm` | Registration class and sales form |
| `bodyType`, `colour`, `power`, `engineVolume`, `co2Emissions` | Specs read from the ad page |
| `drivetrain`, `weight`, `seats`, `doors`, `maxTrailerWeight`, `registrationDate`, `interiorColour` | Further specs read from the ad page |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchAll` | `searchAll`, `searchCars`, `searchElectronics`, `searchFurniture`, or `details`. |
| `query` | string | `laptop` | Keyword to search for. Ignored in details mode. |
| `urls` | array | – | Ad URLs or bare ad IDs for details mode. |
| `priceMin` | integer | – | Minimum price in SEK. |
| `priceMax` | integer | – | Maximum price in SEK. |
| `condition` | string | `any` | `any`, `new`, `likeNew`, `good`, `ok`, `broken` (not for cars). |
| `sellerType` | string | `any` | `any`, `private`, `company`. |
| `tradeType` | string | `any` | `any`, `sell`, `giveAway`, `wanted` (not for cars). |
| `region` | string | `any` | `any` or a Swedish county key such as `stockholm`, `skane`, `vastraGotaland`. |
| `sort` | string | `relevance` | `relevance`, `priceAsc`, `priceDesc`, `newest`, `oldest`. |
| `publishedToday` | boolean | `false` | Only ads published today. |
| `yearMin` | integer | – | Cars: minimum model year. |
| `yearMax` | integer | – | Cars: maximum model year. |
| `mileageMax` | integer | – | Cars: maximum mileage in Swedish mil (1 mil = 10 km). |
| `fuel` | string | `any` | Cars: `petrol`, `diesel`, `electric`, `ethanol`, `gas`, `hybridPetrol`, `hybridDiesel`, `hybridGas`, `plugInPetrol`, `plugInDiesel`. |
| `transmission` | string | `any` | Cars: `automatic`, `manual`, `sequential`. |
| `bodyType` | string | `any` | Cars: `convertible`, `coupe`, `familyVan`, `hatchback3`, `hatchback5`, `estate`, `pickup`, `sedan`, `van`, `suv`, `other`. |
| `includeDetails` | boolean | `false` | Open every search result to add description, condition, category and seller details. Slower. |
| `maxItems` | integer | `20` | Maximum records to return, 1–1000. |

#### Example: keyword search across all categories

```json
{
  "mode": "searchAll",
  "query": "iPhone",
  "priceMax": 5000,
  "sort": "newest",
  "maxItems": 50
}
```

#### Example: cars within a price and model-year range

```json
{
  "mode": "searchCars",
  "query": "Volvo",
  "priceMin": 50000,
  "priceMax": 150000,
  "yearMin": 2018,
  "yearMax": 2024,
  "transmission": "automatic",
  "maxItems": 100
}
```

#### Example: furniture in Stockholm

```json
{
  "mode": "searchFurniture",
  "query": "IKEA soffa",
  "region": "stockholm",
  "condition": "good",
  "maxItems": 40
}
```

#### Example: fetch specific ads by URL or ID

```json
{
  "mode": "details",
  "urls": [
    "https://www.blocket.se/recommerce/forsale/item/28292092",
    "https://www.blocket.se/mobility/item/28293706"
  ]
}
```

### Use cases

- **Price monitoring** — track asking prices for a product or car model over time.
- **Resale sourcing** — find underpriced items in one category or county.
- **Market research** — see what a category actually lists for across Sweden.
- **Inventory alerts** — schedule a narrow search and push new ads into your own system.
- **Ad enrichment** — paste known Blocket URLs and collect the full description and specs.

### Data source and reliability

The actor reads Blocket's public search responses and public ad pages directly. Requests are HTTP-only, use a normal browser identity, retry on rate limits and server errors, and never require user credentials. No browser is launched, so runs stay fast and memory-light.

Blocket paginates searches to a maximum number of pages; when that ceiling is reached the actor stops and reports how many records it returned. For very large result sets, split the query by county, price band, or a narrower keyword.

### FAQ

**Do I need a Blocket account or cookies?**
No. The actor uses Blocket's public listing and ad pages, which are readable without an account.

**What is the difference between the search modes?**
`searchAll` covers every category. `searchElectronics` and `searchFurniture` apply Blocket's own category filter, and `searchCars` uses Blocket's car vertical, which exposes car-specific filters and fields.

**How do I get descriptions and specifications for many ads?**
Set `includeDetails` to `true`. Each record then gets one extra ad-page request, so the run takes longer and returns richer records.

**Why are some seller fields missing?**
Blocket publishes shop names, phones and addresses for company sellers. Private sellers are shown only as `Privat`; their names are not public without logging in, so the actor leaves those fields out.

**Why is `condition` missing on some records?**
Only ads that state a condition have one. With `includeDetails` the value is read from the ad page; otherwise Blocket's search response does not contain it.

**Can I search by city?**
Yes. Add the place name to `query` (for example `laptop Stockholm`), or use the `region` filter for a whole county.

**How many results can one run return?**
Up to `maxItems` (maximum 1000), bounded by Blocket's own pagination limit for that search.

**Are the image URLs stable?**
They point at Blocket's public CDN and open without cookies or a referrer. The `imageUrls` field keeps every image when the ad publishes more than one.

**Is this affiliated with Blocket?**
No. This actor reads Blocket's public listings and is not affiliated with, endorsed by, or connected to Blocket or Schibsted.

# Actor input Schema

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

Search Blocket listings, or fetch full details for specific ads.

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

Keyword to search for, e.g. 'laptop', 'iPhone', 'IKEA soffa' or 'Volvo V60'. Ignored in details mode.

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

Blocket ad links such as https://www.blocket.se/recommerce/forsale/item/28292092, or bare ad IDs. Used only in details mode.

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

Only keep ads priced at or above this amount in Swedish kronor.

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

Only keep ads priced at or below this amount in Swedish kronor.

## `condition` (type: `string`):

Filter by stated item condition. Applies to all categories except cars.

## `sellerType` (type: `string`):

Keep only private sellers or only companies.

## `tradeType` (type: `string`):

For sale, give away, or wanted ads. Applies to all categories except cars.

## `region` (type: `string`):

Limit results to one Swedish county.

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

How Blocket should order the search results.

## `publishedToday` (type: `boolean`):

Only return ads that were published today.

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

Cars only: exclude vehicles older than this model year.

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

Cars only: exclude vehicles newer than this model year.

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

Cars only: maximum mileage in Swedish mil (1 mil = 10 km).

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

Cars only: filter by fuel or powertrain type.

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

Cars only: filter by gearbox type.

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

Cars only: filter by body style.

## `includeDetails` (type: `boolean`):

Also open each listing to add description, condition, category and seller contact details. Slower and uses more requests.

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

Maximum number of listings or details records to return.

## Actor input object example

```json
{
  "mode": "searchAll",
  "query": "laptop",
  "urls": [],
  "condition": "any",
  "sellerType": "any",
  "tradeType": "any",
  "region": "any",
  "sort": "relevance",
  "publishedToday": false,
  "fuel": "any",
  "transmission": "any",
  "bodyType": "any",
  "includeDetails": false,
  "maxItems": 3
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped Blocket listings.

# 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": "searchAll",
    "query": "laptop",
    "urls": [],
    "sort": "relevance",
    "publishedToday": false,
    "includeDetails": false,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/blocket-se-classifieds-search-and-price-filter").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": "searchAll",
    "query": "laptop",
    "urls": [],
    "sort": "relevance",
    "publishedToday": False,
    "includeDetails": False,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/blocket-se-classifieds-search-and-price-filter").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": "searchAll",
  "query": "laptop",
  "urls": [],
  "sort": "relevance",
  "publishedToday": false,
  "includeDetails": false,
  "maxItems": 3
}' |
apify call vexaloom-labs/blocket-se-classifieds-search-and-price-filter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/blocket-se-classifieds-search-and-price-filter"
        }
    }
}
```

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/qndSsHocvugQGEmWi/builds/89yrp0BhFjySpLspX/openapi.json
