# Blocket.se Scraper (`solidcode/blocket-scraper`) Actor

\[💰 $3.0 / 1K] Extract classified ads from Blocket.se — Sweden's biggest second-hand marketplace. Search cars, motorcycles, electronics, furniture, and more. Filter by county, category, price, seller type, and recency.

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

## Pricing

from $3.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.

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 Scraper

Pull classified ads from Blocket.se — Sweden's largest second-hand marketplace — at scale, complete with prices in SEK, GPS coordinates, postal codes, full image galleries, seller details, and rich vehicle specs (make, model, year, mileage in km, fuel, gearbox, registration number, horsepower). Built for Swedish e-commerce sellers tracking resale prices, used-car dealers monitoring the Nordic vehicle market, and analytics teams studying Scandinavian consumer behavior without scraping HTML page by page.

### Why This Scraper?

- **All 21 Swedish counties (län) mapped** — full nationwide coverage from Stockholms län to Norrbottens län, selectable by human-readable county name (not the raw `0.30000`-series codes).
- **14 categories, including 3 vehicle verticals** — Cars (Bilar), Motorcycles (MC), and Boats (Båtar) trigger Blocket's richer mobility schema and pull make, model, year, mileage, fuel, gearbox, registration number, and horsepower on every ad.
- **Native `mil` → kilometres conversion** — Blocket's mobility API returns odometer readings in *Scandinavian mile* (1 mil = 10 km). Every vehicle row is normalized to kilometres so your spreadsheet doesn't lie to you.
- **Up to ~2,650 marketplace ads or ~2,500 vehicle ads per keyword query** — the actor pages through Blocket's full result set automatically, with no manual offset juggling.
- **Five wired-in filters** — price range (SEK), seller type (private vs business vs both), shipping-only (Blocket Frakt), recency window (last 24 hours / 3 / 7 / 9 days), and sort order (newest / cheapest / most expensive) all pushed straight into Blocket's search API.
- **Multi-keyword search + URL-paste mode** — drop in any list of search terms for guided runs, or paste exact Blocket.se URLs (search pages, category pages, or individual ads) for power-user control.
- **34 structured fields per ad** — including latitude/longitude, postal code, the full image array, the seller's profile URL, and the Swedish subcategory under each top-level category.
- **Cross-keyword deduplication by ad ID** — run ten overlapping queries and every ad still appears exactly once in your dataset.

### Use Cases

**Pricing Intelligence & Competitive Analysis**
- Track resale prices for iPhones, Samsung, MacBooks across Swedish counties
- Benchmark your own marketplace prices against live Blocket listings
- Spot underpriced inventory by sorting cheapest-first within a price band

**Used-Vehicle Market Research**
- Monitor the Swedish used-car market by make, model, and county
- Build mileage-vs-price curves for specific Audi, Volvo, or BMW models
- Track boat and motorcycle inventory ahead of the spring buying season

**Lead Generation**
- Build seller contact lists from business dealers across all 21 counties
- Surface car dealerships with the largest active inventory in a given län
- Identify private sellers liquidating high-value electronics or furniture

**Real-Estate & Second-Hand Goods Market Studies**
- Quantify second-hand inventory volume by category and region
- Study price-decay curves for consumer electronics over the 9-day recency window
- Compare urban vs rural pricing for furniture and household goods

**Regional & Demographic Trend Analysis**
- Map second-hand activity by county to identify high-turnover regions
- Compare per-capita listing density across Sweden's 21 län
- Detect seasonal patterns in sport, hobby, and outdoor categories

### Getting Started

#### Simple Keyword Search

```json
{
    "searchQueries": ["iphone"]
}
````

#### Region & Price-Filtered Search

```json
{
    "searchQueries": ["soffa"],
    "region": "stockholm",
    "priceMin": 500,
    "priceMax": 3000
}
```

#### Vehicle Search (cheapest first, last 7 days)

```json
{
    "searchQueries": ["audi a4"],
    "category": "cars",
    "publishedWithin": "7",
    "sortBy": "price-asc",
    "maxResults": 200
}
```

#### Paste a Blocket.se URL

```json
{
    "startUrls": [
        "https://www.blocket.se/annonser/hela_sverige?q=cykel"
    ],
    "maxResults": 50
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["iphone"]` | Keywords to search for (Swedish or English — both work). Each keyword runs as its own search; ads matching multiple keywords are deduplicated by ID. |
| `category` | select | `All categories` | One of: All categories, Cars (Bilar), Motorcycles (MC / Mopeder), Boats (Båtar), Electronics (Elektronik), Furniture & Home (Möbler & Hem), Fashion (Kläder & Accessoarer), Sports & Outdoor (Sport & Fritid), Hobby & Collectibles (Hobby & Samlarprylar), Kids & Baby (Barn & Baby), Pets (Husdjur), Art & Antiques (Konst & Antikt), Garden & Renovation (Trädgård & Renovering), Vehicle Parts (Bildelar & Tillbehör), Business Equipment (Företagsutrustning). Vehicle categories unlock the richer mobility schema. |
| `region` | select | `All of Sweden` | One of 21 Swedish counties: Stockholms län, Uppsala län, Södermanlands län, Östergötlands län, Jönköpings län, Kronobergs län, Kalmar län, Gotlands län, Blekinge län, Skåne län, Hallands län, Västra Götalands län, Värmlands län, Örebro län, Västmanlands län, Dalarnas län, Gävleborgs län, Västernorrlands län, Jämtlands län, Västerbottens län, Norrbottens län — or All of Sweden. |

#### Sorting & Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Newest first` | Order: Newest first (default), Cheapest first, or Most expensive first. |
| `priceMin` | integer | none | Minimum price in Swedish kronor (SEK). |
| `priceMax` | integer | none | Maximum price in Swedish kronor (SEK). |
| `sellerType` | select | `All sellers` | All sellers, Private sellers only, or Business / dealers only. |
| `shippingOnly` | boolean | `false` | Only include ads where the seller offers Blocket Frakt (shipping). |
| `publishedWithin` | select | `Any time` | Recency window: Any time, Last 24 hours, Last 3 days, Last 7 days, or Last 9 days. |

#### Advanced Search (optional)

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | URL\[] | `[]` | Paste Blocket.se URLs directly — search-result pages, category pages, or individual ad pages. When provided, these override the Search / Filters fields above. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of ads to collect across all searches. Set to 0 for no cap (an internal safety limit of 100,000 still applies). |

### Output

One row per ad, flat schema. Vehicle-specific fields are populated only for Cars, Motorcycles, and Boats — they are `null` for marketplace categories.

#### Marketplace Ad Example

```json
{
    "id": "1432109876",
    "url": "https://www.blocket.se/annons/stockholm/iphone_13_pro_max_256gb/1432109876",
    "title": "iPhone 13 Pro Max 256GB Sierra Blue",
    "description": "Säljer min iPhone 13 Pro Max i mycket fint skick. Inga repor på skärmen, batteri 92%. Originallådan och kabel ingår.",
    "price": 6500,
    "currency": "SEK",
    "priceText": "6500 kr",
    "category": "Electronics",
    "subcategory": "Mobiltelefoner",
    "region": "Stockholms län",
    "city": "Södermalm",
    "zipCode": "11824",
    "latitude": 59.3146,
    "longitude": 18.0729,
    "sellerName": "Anna L.",
    "sellerType": "private",
    "sellerUrl": null,
    "shipping": true,
    "condition": "used",
    "brand": "Apple",
    "imageUrl": "https://i.blocketcdn.se/pictures/recommerce/iphone_main.jpg",
    "imageUrls": [
        "https://i.blocketcdn.se/pictures/recommerce/iphone_main.jpg",
        "https://i.blocketcdn.se/pictures/recommerce/iphone_back.jpg"
    ],
    "publishedAt": "2026-05-27T14:22:00Z",
    "searchQuery": "iphone",
    "sourceListUrl": "https://www.blocket.se/recommerce/forsale/search/api/search/SEARCH_ID_BAP_COMMON?q=iphone",
    "scrapedAt": "2026-05-28T09:15:33Z"
}
```

#### Vehicle Ad Example

```json
{
    "id": "987654321",
    "url": "https://www.blocket.se/annons/goteborg/audi_a4_2_0_tdi/987654321",
    "title": "Audi A4 Avant 2.0 TDI quattro S-line",
    "description": "Välskött Audi A4 Avant från 2018. Servad enligt schema, ny besiktning utan anmärkning.",
    "price": 189000,
    "currency": "SEK",
    "priceText": "189000 kr",
    "category": "Cars",
    "subcategory": null,
    "region": "Västra Götalands län",
    "city": "Göteborg",
    "zipCode": "41121",
    "latitude": 57.7089,
    "longitude": 11.9746,
    "sellerName": "Bilhuset Väst AB",
    "sellerType": "business",
    "sellerUrl": null,
    "shipping": false,
    "condition": "used",
    "brand": null,
    "imageUrl": "https://i.blocketcdn.se/pictures/mobility/audi_main.jpg",
    "imageUrls": [
        "https://i.blocketcdn.se/pictures/mobility/audi_1.jpg",
        "https://i.blocketcdn.se/pictures/mobility/audi_2.jpg"
    ],
    "make": "Audi",
    "model": "A4",
    "modelSpec": "Avant 2.0 TDI quattro",
    "year": 2018,
    "mileage": 87500,
    "fuel": "diesel",
    "gearbox": "automatic",
    "regno": "ABC123",
    "horsepower": 190,
    "publishedAt": "2026-05-26T08:45:00Z",
    "searchQuery": "audi a4",
    "sourceListUrl": "https://www.blocket.se/mobility/search/api/search/SEARCH_ID_CAR_USED?q=audi+a4",
    "scrapedAt": "2026-05-28T09:15:33Z"
}
```

#### Core Ad Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Blocket ad ID — unique identifier. |
| `url` | string | Canonical ad URL on Blocket.se. |
| `title` | string | Ad headline as written by the seller. |
| `description` | string | Full free-text body of the ad. |
| `price` | number | Numeric price in SEK. `null` for "Pris på förfrågan" (price on request). |
| `currency` | string | Always `"SEK"`. |
| `priceText` | string | Price as displayed (e.g. `"6500 kr"` or `"Pris på förfrågan"`). |
| `category` | string | Human-readable top-level category (e.g. `"Electronics"`, `"Cars"`). |
| `subcategory` | string | Blocket sub-category (e.g. `"Mobiltelefoner"`). |
| `condition` | string | `"new"`, `"used"`, or `null`. |
| `brand` | string | Brand name for branded goods (marketplace categories). |
| `publishedAt` | string | ISO 8601 timestamp of when the ad was posted. |
| `scrapedAt` | string | ISO 8601 timestamp of when the row was collected. |
| `searchQuery` | string | The keyword that surfaced this ad (for traceability). |
| `sourceListUrl` | string | The listing URL the ad was discovered on. |

#### Location Fields

| Field | Type | Description |
|-------|------|-------------|
| `region` | string | Swedish county name (e.g. `"Stockholms län"`). |
| `city` | string | City or town name. |
| `zipCode` | string | Swedish postal code, when published. |
| `latitude` | number | GPS latitude. |
| `longitude` | number | GPS longitude. |

#### Seller & Shipping

| Field | Type | Description |
|-------|------|-------------|
| `sellerName` | string | Seller display name (business name for dealers; first name + initial for private). |
| `sellerType` | string | `"private"` or `"business"`. |
| `sellerUrl` | string | Public seller profile URL (typically business sellers only). |
| `shipping` | boolean | `true` when the seller offers Blocket Frakt shipping. |

#### Images

| Field | Type | Description |
|-------|------|-------------|
| `imageUrl` | string | URL of the primary listing photo. |
| `imageUrls` | string\[] | Array of every photo URL on the ad (typically 1–20). |

#### Vehicle-Only Fields

Populated for Cars, Motorcycles, and Boats. `null` for all other categories.

| Field | Type | Description |
|-------|------|-------------|
| `make` | string | Manufacturer (e.g. `"Audi"`, `"Volvo"`, `"Yamaha"`). |
| `model` | string | Model name (e.g. `"A4"`, `"XC60"`). |
| `modelSpec` | string | Variant / trim string (e.g. `"Avant 2.0 TDI quattro"`). |
| `year` | number | Model year. |
| `mileage` | number | Odometer reading in **kilometres** (normalized from Blocket's native *mil* unit). |
| `fuel` | string | `"petrol"`, `"diesel"`, `"hybrid"`, `"electric"`, etc. |
| `gearbox` | string | `"manual"` or `"automatic"`. |
| `regno` | string | Swedish vehicle registration number. |
| `horsepower` | number | Engine power in HP, when published. |

### Tips for Best Results

- **Use multiple keywords for broader coverage** — Swedish and English both work (`["soffa", "couch", "3-sits"]`). Results are deduplicated by ad ID, so overlap costs nothing.
- **Per-query pagination ceiling is ~2,650 marketplace ads or ~2,500 vehicle ads** — to go deeper into a hot category, split your search with price bands (`0-500`, `500-2000`, `2000+`) or by county.
- **Pairing `sellerType: "private"` with `category: "cars"` returns near-zero results** — roughly 99% of car ads on Blocket are posted by business dealers. Use `All sellers` or `Business / dealers only` for cars.
- **`publishedWithin` maxes out at 9 days** — Blocket's search API does not support wider time windows. Use `Any time` to include older listings.
- **For vehicle data, pick the dedicated category** (Cars, Motorcycles, or Boats) — only these trigger the mobility schema with make/model/mileage/fuel/gearbox/horsepower extraction.
- **A region filter dramatically reduces noise** for local-market research; pair `region: "skane"` with a tight price band to focus on one län at a time.
- **Combine `priceMin`/`priceMax` with multi-keyword search** to capture specific market segments — e.g. mid-range used phones in Stockholm.

### Pricing

**$3.00 per 1,000 results** — flat pay-per-result, billed only for ads actually delivered to your dataset.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.30 |
| 1,000 | $3.00 |
| 10,000 | $30.00 |
| 100,000 | $300.00 |

A "result" is one row in the output dataset — i.e. one Blocket ad. **No compute charges — you only pay per result returned.** Platform fees (storage, data transfer) depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available classified-ad data from Blocket.se for legitimate market research, pricing intelligence, and competitive analysis. You are responsible for complying with Blocket.se's Terms of Service, the Swedish Marketing Act, and EU/GDPR rules when handling any personal data captured in seller names, contact details, or ad descriptions. Do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search for on Blocket.se (Swedish or English — both work). Each keyword runs as its own search; rows that match more than one keyword are deduplicated by ad ID. Leave empty to scrape the unfiltered listing for the chosen category and region.

## `category` (type: `string`):

Limit results to a single Blocket category. Vehicle categories (Cars, Motorcycles, Boats) use Blocket's richer mobility schema and return extra fields (make, model, year, mileage, fuel, gearbox, registration number).

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

Restrict results to a single Swedish county (län). Leave on 'All of Sweden' to search nationwide.

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

Only include ads at or above this price, in Swedish kronor (SEK). Leave empty for no minimum.

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

Only include ads at or below this price, in Swedish kronor (SEK). Leave empty for no maximum.

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

Filter by who is selling — private individuals only, business dealers only, or both. Note: roughly 99% of car ads on Blocket are posted by dealers, so picking 'Private sellers only' together with the Cars category will typically return zero results.

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

Only include ads where the seller offers shipping (Blocket Frakt). Useful when you can't pick the item up in person.

## `publishedWithin` (type: `string`):

Only include ads posted within this recency window. 'Any' returns all currently active ads. Maximum window is 9 days — Blocket's search API does not support wider time filters.

## `sortBy` (type: `string`):

Order in which to collect results from Blocket. Newest first is the default and gives the most relevant recent ads first.

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

Power-user input. Paste Blocket.se URLs directly — search-result pages (e.g. https://www.blocket.se/annonser/hela\_sverige/elektronik?q=iphone), category pages, or individual ad pages (e.g. https://www.blocket.se/annons/.../12345678). When provided, these override the Search Keywords / Category / Region / Filters fields above.

## `maxResults` (type: `integer`):

Maximum number of ads to collect across all searches and URLs. Set to 0 for no cap (an internal safety limit of 100,000 still applies). Results are collected in full pages, so the final page may overshoot this number by a few rows.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone"
  ],
  "category": "all",
  "region": "all",
  "sellerType": "all",
  "shippingOnly": false,
  "publishedWithin": "any",
  "sortBy": "newest",
  "startUrls": [],
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of ads with the key fields at a glance — title, price, location, category, seller, posted date, and ad URL.

## `details` (type: `string`):

Full per-ad fields including description, photo URLs, vehicle specs, GPS coordinates, seller details, and timestamps.

# 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 = {
    "searchQueries": [
        "iphone"
    ],
    "category": "all",
    "region": "all",
    "sellerType": "all",
    "shippingOnly": false,
    "publishedWithin": "any",
    "sortBy": "newest",
    "startUrls": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["iphone"],
    "category": "all",
    "region": "all",
    "sellerType": "all",
    "shippingOnly": False,
    "publishedWithin": "any",
    "sortBy": "newest",
    "startUrls": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/blocket-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 '{
  "searchQueries": [
    "iphone"
  ],
  "category": "all",
  "region": "all",
  "sellerType": "all",
  "shippingOnly": false,
  "publishedWithin": "any",
  "sortBy": "newest",
  "startUrls": [],
  "maxResults": 100
}' |
apify call solidcode/blocket-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Blocket.se Scraper",
        "description": "[💰 $3.0 / 1K] Extract classified ads from Blocket.se — Sweden's biggest second-hand marketplace. Search cars, motorcycles, electronics, furniture, and more. Filter by county, category, price, seller type, and recency.",
        "version": "1.0",
        "x-build-id": "jXet3Wg9wFVlelmM3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~blocket-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-blocket-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/solidcode~blocket-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-blocket-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/solidcode~blocket-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-blocket-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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for on Blocket.se (Swedish or English — both work). Each keyword runs as its own search; rows that match more than one keyword are deduplicated by ad ID. Leave empty to scrape the unfiltered listing for the chosen category and region.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "cars",
                            "motorcycles",
                            "boats",
                            "electronics",
                            "furniture-home",
                            "fashion",
                            "sports-outdoor",
                            "hobby",
                            "kids-baby",
                            "pets",
                            "art-antiques",
                            "garden-renovation",
                            "vehicle-parts",
                            "business-equipment"
                        ],
                        "type": "string",
                        "description": "Limit results to a single Blocket category. Vehicle categories (Cars, Motorcycles, Boats) use Blocket's richer mobility schema and return extra fields (make, model, year, mileage, fuel, gearbox, registration number).",
                        "default": "all"
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "all",
                            "stockholm",
                            "uppsala",
                            "sodermanland",
                            "ostergotland",
                            "jonkoping",
                            "kronoberg",
                            "kalmar",
                            "gotland",
                            "blekinge",
                            "skane",
                            "halland",
                            "vastra-gotaland",
                            "varmland",
                            "orebro",
                            "vastmanland",
                            "dalarna",
                            "gavleborg",
                            "vasternorrland",
                            "jamtland",
                            "vasterbotten",
                            "norrbotten"
                        ],
                        "type": "string",
                        "description": "Restrict results to a single Swedish county (län). Leave on 'All of Sweden' to search nationwide.",
                        "default": "all"
                    },
                    "priceMin": {
                        "title": "Minimum Price (SEK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include ads at or above this price, in Swedish kronor (SEK). Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (SEK)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include ads at or below this price, in Swedish kronor (SEK). Leave empty for no maximum."
                    },
                    "sellerType": {
                        "title": "Seller Type",
                        "enum": [
                            "all",
                            "private",
                            "business"
                        ],
                        "type": "string",
                        "description": "Filter by who is selling — private individuals only, business dealers only, or both. Note: roughly 99% of car ads on Blocket are posted by dealers, so picking 'Private sellers only' together with the Cars category will typically return zero results.",
                        "default": "all"
                    },
                    "shippingOnly": {
                        "title": "Shippable Ads Only",
                        "type": "boolean",
                        "description": "Only include ads where the seller offers shipping (Blocket Frakt). Useful when you can't pick the item up in person.",
                        "default": false
                    },
                    "publishedWithin": {
                        "title": "Published Within",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "9"
                        ],
                        "type": "string",
                        "description": "Only include ads posted within this recency window. 'Any' returns all currently active ads. Maximum window is 9 days — Blocket's search API does not support wider time filters.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "newest",
                            "price-asc",
                            "price-desc"
                        ],
                        "type": "string",
                        "description": "Order in which to collect results from Blocket. Newest first is the default and gives the most relevant recent ads first.",
                        "default": "newest"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste Blocket.se URLs directly — search-result pages (e.g. https://www.blocket.se/annonser/hela_sverige/elektronik?q=iphone), category pages, or individual ad pages (e.g. https://www.blocket.se/annons/.../12345678). When provided, these override the Search Keywords / Category / Region / Filters fields above.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of ads to collect across all searches and URLs. Set to 0 for no cap (an internal safety limit of 100,000 still applies). Results are collected in full pages, so the final page may overshoot this number by a few rows.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
