# Hemnet Scraper – Swedish Real Estate Listings & Sold Prices (`haketa/hemnet-scraper`) Actor

Hemnet scraper & API for Swedish real estate: search homes for sale and sold listings (slutpriser) and export address, asking and final price, rooms, living area, fee, type, agent and coordinates. Sweden property and sold-price market data — fast, no login.

- **URL**: https://apify.com/haketa/hemnet-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Features:** Limited permissions
- **Stats:** 29 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Hemnet Scraper — Swedish Real Estate Listings & Sold Prices (Slutpriser)

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00B5AD?style=for-the-badge\&logo=apify\&logoColor=white)](https://apify.com/haketa/hemnet-scraper)
[![Target](https://img.shields.io/badge/Target-Hemnet.se-2E7D32?style=for-the-badge)](https://www.hemnet.se)
[![Market](https://img.shields.io/badge/Market-Sweden%20%F0%9F%87%B8%F0%9F%87%AA-006AA7?style=for-the-badge)]()
[![Data](https://img.shields.io/badge/Data-For%20Sale%20%2B%20Slutpriser-F57C00?style=for-the-badge)]()
[![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-4A148C?style=for-the-badge)]()

**Scrape [Hemnet.se](https://www.hemnet.se) — Sweden's leading real estate marketplace — and export clean, structured property data in seconds.** This **Hemnet scraper** extracts both **active homes for sale (till salu)** and **historical sold prices (slutpriser)**: asking price, final sale price, price change amount and percentage, SEK/m², monthly BRF fee, room count, living area, plot area, street address, neighborhood, municipality, listing broker, real estate agency, high-resolution images, and GPS coordinates. **No login, no coding, and zero maintenance.**

Export your Swedish housing dataset directly to **JSON, CSV, Excel, XML, RSS, or via the Apify API** for automated valuation models (AVMs), PropTech applications, mortgage analytics, and real estate B2B intelligence.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Target platform** | [Hemnet.se](https://www.hemnet.se) — Sweden real estate portal |
| **Listing modes** | Active homes **For sale (`forSale` / till salu)** and **Sold prices (`sold` / slutpriser)** |
| **Property types** | Apartments (`bostadsratt`), Houses (`villa`), Townhouses (`radhus`), Vacation homes (`fritidshus`), Land (`tomt`), Farms (`gard`), Other |
| **Search inputs** | Built-in **Region dropdown** (15 major Swedish municipalities), **Start URLs**, or free-text **Location** |
| **Filter controls** | Min/max price (SEK), min/max rooms, min/max living area (m²), sold-within window (`1m`, `3m`, `12m`, `all`) |
| **Detail enrichment** | Optional full property descriptions and image galleries (`fetchDetails: true`) |
| **Pagination & scale** | Automatic multi-page crawling (up to ~2,500 listings per search, unlimited across multiple regions/URLs) with 100% ID de-duplication |
| **Output formats** | JSON, CSV, Excel (XLSX), XML, RSS, and REST API |

***

### 📋 Table of contents

- [Why scrape Hemnet?](#-why-scrape-hemnet)
- [What this Hemnet scraper does](#-what-this-hemnet-scraper-does)
- [Use cases](#-use-cases)
- [Input configuration](#-input-configuration)
- [Output & field reference](#-output--field-reference)
- [Pagination & 1,000+ scale](#-pagination--1000-scale)
- [How to use](#-how-to-use)
- [Pro tips for Swedish property data](#-pro-tips-for-swedish-property-data)
- [FAQ](#-faq)
- [Related scrapers](#-related-scrapers)
- [Changelog](#-changelog)

***

### 🔎 Why scrape Hemnet?

[Hemnet](https://www.hemnet.se) is the central hub for buying and selling residential property in Sweden, capturing **over 90% of all Swedish home transactions**. Millions of buyers and sellers use it weekly, making Hemnet the single richest public repository of Swedish housing market intelligence — covering both **live inventory on the market right now** and a deep historical archive of **verified final transaction prices (slutpriser)**.

However, Hemnet does not offer a public bulk export, spreadsheet download, or open developer API. Copying listings manually across Stockholm, Göteborg, Malmö, or Uppsala does not scale past a few dozen properties, and custom scripts require constant updates whenever the front-end changes. This **Hemnet data extractor** automates the entire workflow and delivers a normalized, de-duplicated dataset ready for analytics, BI dashboards, or machine-learning pipelines.

#### Key business outcomes

- 💰 **Build Automated Valuation Models (AVMs) & CMAs** — anchor property valuations on verified historical sold prices (`finalPrice`), square-meter pricing (`squareMeterPrice`), and bidding premiums (`priceChangePercent`).
- 📈 **Track asking vs. final transaction prices** — measure bidding heat across Swedish neighborhoods (`area`) and municipalities (`municipality`) over 1-month, 3-month, or 12-month windows.
- 🏦 **Feed mortgage, underwriting & collateral risk models** — supply banks, credit teams, and insurers with granular Swedish housing comparables and monthly association fees (`fee`).
- 🏘️ **Benchmark agency & broker market share** — analyze which real estate agencies (`brokerAgency`) and brokers (`broker`) dominate specific municipalities or price brackets.
- 🎯 **Power PropTech & B2B lead generation** — discover newly listed properties and active real estate agents for relocation, renovation, mortgage, and B2B software outreach.
- 🗺️ **Run geospatial housing analysis** — plot inventory density, SEK/m² heatmaps, and yield potential using exact `latitude` and `longitude` coordinates.

***

### ✨ What this Hemnet scraper does

- ✅ **Two complete datasets in one actor** — switch seamlessly between homes **for sale (`forSale` / till salu)** and historical **sold prices (`sold` / slutpriser)** with final transaction amounts and bidding deltas.
- ✅ **Zero-friction Swedish region selector** — pick from Sweden's top municipalities in the **Region** dropdown (Stockholm, Göteborg, Malmö, Uppsala, Västerås, Örebro, Linköping, Helsingborg, Norrköping, Jönköping, Lund, Umeå, Mölndal, Halmstad, Södertälje), enter a free-text city name, or paste any **Hemnet search URL**.
- ✅ **Granular property & price filtering** — filter by dwelling category (`bostadsratt`, `villa`, `radhus`, `fritidshus`, `tomt`, `gard`), price floor/ceiling in SEK, room count range, living area in m², and sold-date window (`1m`, `3m`, `12m`, `all`).
- ✅ **Deep 1,000+ result pagination & de-duplication** — walks result pages automatically (`?page=1`, `?page=2`, …) governed by your `maxItems` target, de-duplicating every record by its canonical Hemnet `id`.
- ✅ **Normalized financial & structural metrics** — outputs numeric `askingPrice`, `finalPrice`, `priceChange`, `priceChangePercent`, `squareMeterPrice`, `fee`, `livingArea`, `supplementalArea`, and `plotArea` ready for immediate math in Excel, SQL, or Python.
- ✅ **Optional full-detail enrichment** — enable `fetchDetails: true` to visit each individual listing page and extract the complete property `description` and full `images` gallery array.
- ✅ **Smart cost-optimized proxy routing** — automatically pairs fast datacenter requests with Swedish residential fallback when needed, keeping runs fast, reliable, and cost-effective.

***

### 🎯 Use cases

| Audience | How they use Hemnet data |
|---|---|
| **🏦 Real Estate Investors & Funds** | Track sold prices (`slutpriser`) vs. asking prices across Swedish districts, spot undervalued submarkets, and model acquisition yields. |
| **💻 PropTech Startups & Portals** | Power consumer valuation tools, home-search alerts, and neighborhood comparison apps with live Swedish property feeds. |
| **📊 Market Researchers & Economists** | Quantify housing supply, SEK/m² trends, BRF monthly fee inflation, and bidding-war intensity across Sweden's municipalities. |
| **🏘️ Real Estate Agencies & Brokers** | Automate comparative market analysis (CMA) packs for sellers and track competing agency inventory in real time. |
| **💳 Mortgage Lenders & FinTechs** | Validate property collateral values against recent neighborhood sales and factor monthly BRF fees (`fee`) into affordability models. |
| **🎯 B2B Sales & Lead Generation** | Extract active brokers (`broker`) and agencies (`brokerAgency`) alongside new property listings for targeted B2B outreach. |

***

### 📥 Input configuration

Configure your run via the Apify Console UI or pass a JSON payload through the API. **All fields are optional** — running with an empty input `{}` automatically collects a fast, diverse sample across Sweden's three largest housing markets (Stockholm, Göteborg, and Malmö).

| Field | Type | Default | Description |
|---|---|---|---|
| `listingType` | `string` | `"forSale"` | Choose `"forSale"` (homes currently on the market / till salu) or `"sold"` (historical sold prices / slutpriser). |
| `region` | `array` | `[]` | Select one or more Swedish municipalities from the dropdown (Stockholm, Göteborg, Malmö, Uppsala, Lund, etc.). Leave empty for a nationwide sample. |
| `propertyTypes` | `array` | `[]` | Filter by dwelling type: `"bostadsratt"`, `"villa"`, `"radhus"`, `"fritidshus"`, `"tomt"`, `"gard"`, `"other"`. Empty = all types. |
| `soldAge` | `string` | `"12m"` | Time window for sold properties: `"1m"` (last month), `"3m"` (last 3 months), `"12m"` (last 12 months), or `"all"` (all time). Ignored when `listingType` is `"forSale"`. |
| `priceMin` | `integer` | — | Minimum price in Swedish kronor (SEK). |
| `priceMax` | `integer` | — | Maximum price in Swedish kronor (SEK). |
| `roomsMin` | `integer` | — | Minimum number of rooms. |
| `roomsMax` | `integer` | — | Maximum number of rooms. |
| `livingAreaMin` | `integer` | — | Minimum living area (`boarea`) in square meters (m²). |
| `livingAreaMax` | `integer` | — | Maximum living area (`boarea`) in square meters (m²). |
| `fetchDetails` | `boolean` | `false` | Visit each property's detail page to also extract the full text `description` and `images` array. Keep `false` for fast, high-volume list scraping. |
| `maxItems` | `integer` | `0` (prefill `100`) | Maximum number of properties to collect across the run (`0` = unlimited). |
| `maxPagesPerSearch` | `integer` | `0` | Maximum result pages to crawl per search (`0` = automatic / unlimited, governed by `maxItems`). A single Hemnet search serves up to 50 pages (~2,500 properties). |
| `location` | `string` | — | Optional free-text location name (e.g. `"Visby"`, `"Kiruna"`, `"Kalmar"`). Automatically resolved to a Hemnet location ID. |
| `startUrls` | `array` | `[]` | Advanced: paste one or more search URLs copied directly from `hemnet.se` (`/bostader?...` or `/salda/bostader?...`). Automatically detects for-sale vs. sold mode. |
| `proxyConfiguration` | `object` | Apify Proxy | Proxy configuration. Leave on Apify Proxy for automatic fast datacenter + Swedish residential fallback. |

#### Example 1 — Apartments for sale in Stockholm (1,000+ deep crawl)

```json
{
  "listingType": "forSale",
  "region": ["17744"],
  "propertyTypes": ["bostadsratt"],
  "priceMin": 2000000,
  "priceMax": 8000000,
  "roomsMin": 2,
  "maxItems": 1000,
  "maxPagesPerSearch": 0
}
```

#### Example 2 — Historical sold houses (slutpriser) in Göteborg & Malmö

```json
{
  "listingType": "sold",
  "region": ["17920", "17989"],
  "propertyTypes": ["villa", "radhus"],
  "soldAge": "12m",
  "maxItems": 1500
}
```

#### Example 3 — Custom Hemnet search URL with full property descriptions

```json
{
  "startUrls": [
    { "url": "https://www.hemnet.se/salda/bostader?location_ids%5B%5D=17744&item_types%5B%5D=bostadsratt&sold_age=3m" }
  ],
  "fetchDetails": true,
  "maxItems": 200
}
```

***

### 📤 Output & field reference

Each scraped property is stored as a structured JSON object in the Apify Dataset. All records share a unified schema across `"forSale"` and `"sold"` runs so you can load them into SQL tables, Pandas DataFrames, or BI tools without schema drift.

#### Sample output — Sold apartment (`listingType: "sold"`)

```json
{
  "listingType": "sold",
  "id": "21777507",
  "url": "https://www.hemnet.se/salda/lagenhet-2rum-ostermalm-stockholms-kommun-jungfrugatan-11-517326341071314857",
  "propertyType": "Lägenhet",
  "address": "Jungfrugatan 11",
  "area": "Östermalm, Stockholms kommun",
  "municipality": "Stockholms kommun",
  "county": null,
  "askingPrice": 5995000,
  "finalPrice": 7260000,
  "priceChange": 1265000,
  "priceChangePercent": 21,
  "squareMeterPrice": 154468,
  "fee": 1865,
  "rooms": "2 rum",
  "livingArea": 47,
  "supplementalArea": null,
  "plotArea": null,
  "floor": null,
  "constructionYear": null,
  "publishedAt": null,
  "soldDate": "2026-11-01",
  "broker": "Alexander Brito",
  "brokerAgency": "Behrer & Partners",
  "latitude": 59.3370697,
  "longitude": 18.081687,
  "thumbnail": "https://bilder.hemnet.se/images/itemgallery_cut/...",
  "scrapedAt": "2026-11-02T00:00:00.000Z"
}
```

#### Sample output — Active listing (`listingType: "forSale"`)

```json
{
  "listingType": "forSale",
  "id": "21906349",
  "url": "https://www.hemnet.se/bostad/lagenhet-2rum-bredang-malarhojden-stockholms-kommun-algrytevagen-31-21906349",
  "propertyType": "Lägenhet",
  "address": "Ålgrytevägen 31",
  "area": "Bredäng - Mälarhöjden, Stockholms kommun",
  "municipality": "Stockholms kommun",
  "county": null,
  "askingPrice": 2495000,
  "finalPrice": null,
  "priceChange": null,
  "priceChangePercent": null,
  "squareMeterPrice": 50918,
  "fee": 3862,
  "rooms": "2 rum",
  "livingArea": 49,
  "supplementalArea": null,
  "plotArea": null,
  "floor": "vån 5/7",
  "constructionYear": null,
  "publishedAt": "2026-10-25",
  "soldDate": null,
  "broker": "Yousif Gorges",
  "brokerAgency": "HusmanHagberg Hägersten",
  "latitude": 59.2984962,
  "longitude": 17.9413223,
  "thumbnail": "https://bilder.hemnet.se/images/itemgallery_cut/...",
  "scrapedAt": "2026-11-02T00:00:00.000Z"
}
```

#### Field reference by category

##### 🏷️ Identity & classification

| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | `string` | 🟢 High (~100%) | Unique Hemnet listing or sale ID (natural primary key used for de-duplication). |
| `listingType` | `string` | 🟢 High (100%) | `"forSale"` (active listing) or `"sold"` (historical sold record). |
| `url` | `string` | 🟢 High (100%) | Direct canonical URL to the property or sold-price page on `hemnet.se`. |
| `propertyType` | `string` | 🟢 High (~100%) | Swedish dwelling category (e.g., `Lägenhet`, `Villa`, `Radhus`, `Fritidshus`, `Tomt`, `Gård`). |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO 8601 UTC timestamp indicating when the record was collected. |

##### 💰 Pricing, bidding & association fees

| Field | Type | Coverage | Description |
|---|---|---|---|
| `askingPrice` | `number \| null` | 🟢 High (~99%) | Listed asking price (`utgångspris`) in SEK. `null` only on "price on request" listings. |
| `finalPrice` | `number \| null` | 🟡 Conditional | Final transaction price (`slutpris`) in SEK — populated (~100%) when `listingType: "sold"`. |
| `priceChange` | `number \| null` | 🟡 Conditional | Difference between `finalPrice` and `askingPrice` in SEK (`finalPrice - askingPrice`) — sold listings. |
| `priceChangePercent` | `number \| null` | 🟡 Conditional | Percentage difference between asking and final sale price (e.g., `21` = +21%) — sold listings. |
| `squareMeterPrice` | `number \| null` | 🟢 High (~95%) | Price per square meter (`kr/m²`) in SEK. |
| `fee` | `number \| null` | 🟡 Conditional | Monthly housing association (`BRF`) fee (`avgift`) in SEK — populated for apartments (`bostadsrätt`) and cooperative townhouses. |

##### 📐 Dimensions & building specs

| Field | Type | Coverage | Description |
|---|---|---|---|
| `rooms` | `string \| null` | 🟢 High (~96%) | Room count formatted as published (e.g., `"2 rum"`, `"4,5 rum"`). |
| `livingArea` | `number \| null` | 🟢 High (~98%) | Primary living area (`boarea`) in square meters (m²). |
| `supplementalArea` | `number \| null` | 🟡 Conditional | Supplemental / secondary area (`biarea`) in m² — mainly houses and townhouses. |
| `plotArea` | `number \| null` | 🟡 Conditional | Land / plot surface (`tomtarea`) in m² — populated for houses, vacation homes, farms, and plots. |
| `floor` | `string \| null` | 🟡 Conditional | Apartment floor level and total building floors (e.g., `"vån 5/7"`). |
| `constructionYear` | `string \| null` | 🟡 Conditional | Building construction year when exposed on the listing. |

##### 📍 Location & geospatial coordinates

| Field | Type | Coverage | Description |
|---|---|---|---|
| `address` | `string \| null` | 🟢 High (~100%) | Street address or property name (e.g., `"Jungfrugatan 11"`). |
| `area` | `string \| null` | 🟢 High (~100%) | Neighborhood / district label, usually including the municipality. |
| `municipality` | `string \| null` | 🟢 High (~100%) | Swedish municipality (`kommun`), e.g., `"Stockholms kommun"`. |
| `county` | `string \| null` | 🟡 Conditional | Swedish county (`län`) when present on the record. |
| `latitude` | `number \| null` | 🟢 High (~99%) | WGS84 GPS latitude coordinate. |
| `longitude` | `number \| null` | 🟢 High (~99%) | WGS84 GPS longitude coordinate. |

##### 🤝 Broker, dates & media

| Field | Type | Coverage | Description |
|---|---|---|---|
| `broker` | `string \| null` | 🟡 Conditional | Name of the listing real estate agent (`mäklare`) when published on the card. |
| `brokerAgency` | `string \| null` | 🟢 High (~98%) | Real estate agency / brokerage office (`mäklarbyrå`). |
| `publishedAt` | `string \| null` | 🟡 Conditional | Publication date (`YYYY-MM-DD`) — populated for active `forSale` listings. |
| `soldDate` | `string \| null` | 🟡 Conditional | Sale date (`YYYY-MM-DD`) — populated for `sold` listings. |
| `thumbnail` | `string \| null` | 🟢 High (~98%) | Primary property image URL on `bilder.hemnet.se`. |
| `description` | `string` | 🟡 Detail mode | Full property description text — added when `fetchDetails: true`. |
| `images` | `array` | 🟡 Detail mode | Array of high-resolution gallery image URLs (up to 60) — added when `fetchDetails: true`. |

***

### 🔁 Pagination & 1,000+ scale

This **Hemnet scraper** is engineered for deep, multi-page extraction:

1. **Automatic page traversal:** Every search walks `?page=1`, `?page=2`, `?page=3`… (~50 properties per page) automatically until your `maxItems` target is reached or the search has no further pages.
2. **Unlocked `maxPagesPerSearch: 0` default:** By default, `maxPagesPerSearch` is `0` (unlimited / automatic), so setting `maxItems: 1000` or `maxItems: 5000` automatically paginates as deep as needed without hitting artificial page caps.
3. **Cross-search de-duplication:** Every property is tracked in an in-memory `Set` keyed by its Hemnet `id`, ensuring **0 duplicate records** even when overlapping regions or URLs are combined.
4. **Scaling past Hemnet's 2,500-result per-search limit:** Hemnet caps any single search query at 50 pages (~2,500 properties). To extract **5,000, 10,000, or 50,000+ properties** in a single run:
   - Select multiple municipalities in the **`region`** array (e.g., Stockholm + Göteborg + Malmö + Uppsala + Lund), **or**
   - Paste multiple filtered search URLs (sliced by municipality, property type, or price bracket) into **`startUrls`**.

***

### ⚙️ How to use

1. **Open the actor** in the Apify Console.
2. **Select `listingType`** — pick *For sale (till salu)* for live inventory or *Sold prices (slutpriser)* for historical transaction data.
3. **Choose your target area** — pick one or more Swedish cities from the **Region** dropdown, type a city in **Location**, or paste custom URLs into **Start URLs**.
4. **Set filters & volume** — optionally filter by `propertyTypes`, `priceMin`/`priceMax`, `roomsMin`/`roomsMax`, `livingAreaMin`/`livingAreaMax`, and set `maxItems` (e.g., `100`, `1000`, or `0` for all available).
5. **Click Start** — watch structured property records stream into the Dataset in real time.
6. **Export or integrate** — download as **JSON, CSV, Excel, XML, or RSS**, or consume the dataset via the **Apify REST API**, Python/JS SDKs, Make, Zapier, n8n, Google Sheets, or webhooks.

#### Calling via the Apify API (Node.js)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('haketa/hemnet-scraper').call({
    listingType: 'sold',
    region: ['17744', '17920'],
    propertyTypes: ['bostadsratt'],
    soldAge: '12m',
    maxItems: 1000,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Retrieved ${items.length} Swedish property records.`);
```

***

### 💡 Pro tips for Swedish property data

- 🔗 **Use Start URLs for micro-neighborhoods or custom polygons:** Open `hemnet.se`, select any specific street, district (e.g. *Södermalm*, *Östermalm*, *Linnéstaden*), or custom filter combination, copy the URL from your browser address bar, and paste it into `startUrls`.
- 💰 **Combine `forSale` and `sold` runs for AVM & yield modeling:** Run two jobs with identical `region` and `propertyTypes` — one with `listingType: "forSale"` and one with `listingType: "sold"` (`soldAge: "3m"` or `"12m"`) — to compare current asking SEK/m² against realized transaction SEK/m².
- ⚡ **Keep `fetchDetails: false` for large market sweeps:** All pricing, area, room, fee, location, broker, and coordinate fields are extracted directly from the search pages at high speed. Enable `fetchDetails: true` only when you specifically need the full text description and full photo gallery.
- 📅 **Schedule recurring runs:** Pair the actor with Apify Schedules (daily or weekly) to track newly listed homes, monitor price adjustments, and maintain a rolling database of Swedish `slutpriser`.

***

### ❓ FAQ

#### Does this scraper extract both active listings and sold prices (slutpriser)?

Yes. Set `listingType` to `"forSale"` for active properties on the market, or `"sold"` to extract historical sold properties with `finalPrice`, `priceChange`, `priceChangePercent`, and `soldDate`.

#### How many properties can I extract in a single run?

You can collect **hundreds to tens of thousands** of properties per run. Set `maxItems: 1000` (or `0` for unlimited) and `maxPagesPerSearch: 0`. Because Hemnet limits any single search query to 50 pages (~2,500 listings), pass multiple regions or multiple `startUrls` to collect 5,000+ records in one job.

#### Do I need a Hemnet account or special proxies?

No login or account is needed. Leave `proxyConfiguration` on the default Apify Proxy — the actor automatically manages IP selection to keep runs fast and reliable.

#### Why is `askingPrice` occasionally `null`?

A small percentage of luxury or new-development listings on Hemnet are published as *"Pris på förfrågan"* (price on request) without a numeric asking price.

#### Can I scrape commercial properties, plots, or farms?

Yes. In `propertyTypes`, select `"tomt"` (plots/land), `"gard"` (farms/estates), `"fritidshus"` (vacation homes), or `"other"` — or paste any specialized Hemnet search URL into `startUrls`.

***

### 🔗 Related scrapers

Building a Nordic or European real estate intelligence pipeline? Combine **Hemnet Scraper** with our other property extractors:

- 🇩🇰 [Boliga Scraper](https://apify.com/haketa/boliga-scraper) — Danish property listings and historical sold prices.
- 🇧🇪 [Immoweb Scraper](https://apify.com/haketa/immoweb-scraper) — Belgium's #1 real estate portal (for sale & rent across Flanders, Wallonia, and Brussels).
- 🇩🇪 [ImmobilienScout24 Scraper](https://apify.com/haketa/immobilienscout24-scraper) — Germany's largest real estate marketplace.
- 🇮🇱 [Yad2 Scraper](https://apify.com/haketa/yad2-scraper) — Israel real estate and classifieds listings.
- 🇧🇷 [ZAP Imóveis Scraper](https://apify.com/haketa/zapimoveis-scraper) — Brazilian residential and commercial property listings.
- 🇦🇺 [Domain.com.au Scraper](https://apify.com/haketa/domain-com-au-scraper) — Australian property listings and auction results.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ deep pagination:** Changed `maxPagesPerSearch` default to `0` (automatic/unlimited, governed by `maxItems`) and removed the artificial 100-item clamp when `maxItems > 100` is specified on nationwide runs.
- **Documentation & schema upgrade:** Added comprehensive field coverage tables, multi-region scaling guide, and updated input descriptions.

#### v1.1 (2026-10)

- **Next.js App Router support:** Added full parsing for Hemnet's RSC flight stream alongside legacy state payloads for 100% field continuity across both active (`ListingCard`) and sold (`SaleCard`) listings.
- **De-duplication improvement:** Preserved internal IDs on older expired sold cards so every historical sale record is retained.

#### v1.0 (2026-05)

- Initial release supporting Swedish homes for sale (`till salu`), sold prices (`slutpriser`), region selector, property filters, and optional detail enrichment.

# Changelog

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

# Actor input Schema

## `listingType` (type: `string`):

Scrape homes that are currently FOR SALE, or historical SOLD prices (slutpriser) with final sale amounts.

## `region` (type: `array`):

Choose one or more Swedish cities / municipalities to scrape. Leave empty to get a nationwide sample from Sweden's biggest markets.

## `propertyTypes` (type: `array`):

Which dwelling types to include. Leave empty to include all types.

## `soldAge` (type: `string`):

Time window for sold listings. Ignored when scraping homes for sale.

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

Only include properties priced at or above this amount, in Swedish kronor. Leave empty for no minimum.

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

Only include properties priced at or below this amount, in Swedish kronor. Leave empty for no maximum.

## `roomsMin` (type: `integer`):

Only include properties with at least this many rooms. Leave empty for no minimum.

## `roomsMax` (type: `integer`):

Only include properties with at most this many rooms. Leave empty for no maximum.

## `livingAreaMin` (type: `integer`):

Only include properties with at least this living area in square meters. Leave empty for no minimum.

## `livingAreaMax` (type: `integer`):

Only include properties with at most this living area in square meters. Leave empty for no maximum.

## `fetchDetails` (type: `boolean`):

Visit each property page to also collect the full description, all image URLs, association (BRF) info and extra attributes. Slower and uses more traffic.

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

Stop after collecting this many properties (0 = no limit). Note: a single Hemnet search returns at most ~2,500 results.

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

Optional. If your city is not in the Region dropdown, type a place name (e.g. "Visby", "Kiruna") and the actor will try to resolve it. For guaranteed results, prefer the Region dropdown or Start URLs.

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

Power-user option. Open hemnet.se, set any filters you like, then copy the URL from your browser and paste it here. Works for homes for sale (https://www.hemnet.se/bostader?...) and sold prices (https://www.hemnet.se/salda/bostader?...). Sold vs. for-sale is detected automatically from the URL.

## `maxPagesPerSearch` (type: `integer`):

Maximum number of result pages to crawl per search (0 = automatic / unlimited, governed by Max results). A single Hemnet search returns up to 50 pages (~2,500 properties).

## `proxyConfiguration` (type: `object`):

Leave as Apify Proxy (recommended). The actor automatically uses fast datacenter IPs first and falls back to Swedish residential IPs when needed, keeping runs reliable and low‑cost. To force a specific pool, pick the groups yourself.

## Actor input object example

```json
{
  "listingType": "forSale",
  "region": [],
  "propertyTypes": [],
  "soldAge": "12m",
  "fetchDetails": false,
  "maxItems": 100,
  "startUrls": [],
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Active listings and sold prices collected from Hemnet.

# 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 = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/hemnet-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 = {
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/hemnet-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/hemnet-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/hemnet-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/R3GeDRJBK6Hc4D3r8/builds/cDiXn6PAUSjdWkjL8/openapi.json