# Hemnet Swedish Real Estate Scraper (`automation-lab/hemnet-swedish-real-estate-scraper`) Actor

🏠 Extract current and sold Hemnet properties with normalized prices, areas, fees, brokers, dates, images, links, and coordinates for Swedish market research.

- **URL**: https://apify.com/automation-lab/hemnet-swedish-real-estate-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Hemnet Swedish Real Estate Scraper

Extract structured **current and sold Swedish property listings from Hemnet** without building and maintaining your own crawler.

Use a Hemnet search URL or numeric location ID and receive analysis-ready prices, rooms, areas, fees, brokers, dates, images, coordinates, and source links.

The Actor is designed for recurring inventory tracking, sold-comparable research, broker intelligence, valuation inputs, and Swedish housing-market datasets.

### What does Hemnet Swedish Real Estate Scraper do?

The Actor reads public Hemnet search result pages and converts each property card into a normalized dataset row.

It supports:

- 🏠 current homes for sale;
- ✅ sold-property records;
- 🔎 existing Hemnet search URLs and their filters;
- 📍 Hemnet numeric location IDs;
- 📄 multi-page extraction;
- 🔁 current and sold extraction in one run;
- 🌐 optional Apify Proxy routing;
- 📦 JSON, CSV, Excel, XML, and API exports.

No Hemnet login is required for the supported public data.

### Who is it for?

#### Real-estate analysts

Build repeatable inventories and comparable-sales datasets instead of copying property cards manually.

#### Brokers and agencies

Track active supply, sold prices, broker attribution, and agency presence by Swedish location.

#### Investors and buyers

Compare asking prices, final prices, areas, fees, and price per square meter.

#### Proptech and valuation teams

Feed normalized public property observations into dashboards, models, alerts, and enrichment pipelines.

#### Lead and data providers

Discover public listings and associated broker or agency names with source lineage.

### Why use this Hemnet scraper?

- **One schema for current and sold homes** makes comparisons easy.
- **Swedish values become numbers**, such as `4 995 000 kr` → `4995000`.
- **Dates become ISO timestamps** for databases and BI tools.
- **Filters are preserved** when you paste an existing Hemnet search URL.
- **Pagination is automatic** within your item and page limits.
- **Records are deduplicated** by status and Hemnet identifier.
- **Browser-grade HTTP fingerprinting** avoids the overhead of a full browser.
- **Explicit failures** prevent blocked pages from appearing as successful empty datasets.

### What data can you extract?

| Field | Description |
|---|---|
| `propertyId` | Stable card identifier |
| `listingId` | Hemnet listing identifier when exposed |
| `status` | `current` or `sold` |
| `address` | Street address |
| `location` | Area and municipality |
| `housingType` | Apartment, villa, plot, and other type |
| `askingPriceSek` | Asking price as a number |
| `finalPriceSek` | Final sold price when available |
| `priceChangePercent` | Difference from asking price |
| `rooms` | Number of rooms |
| `livingAreaM2` | Living area in square meters |
| `supplementalAreaM2` | Supplemental area when exposed |
| `landAreaM2` | Land area |
| `monthlyFeeSek` | Monthly association fee |
| `pricePerM2Sek` | Price per square meter |
| `floor` | Floor description |
| `publishedAt` | Publication timestamp |
| `soldAt` | Sale timestamp |
| `brokerName` | Public broker name |
| `agencyName` | Public agency name |
| `labels` | Features and promotion labels |
| `description` | Result-card description when available |
| `imageUrl` | Main property image |
| `detailUrl` | Hemnet property URL |
| `latitude`, `longitude` | Coordinates when exposed |
| `sourceUrl` | Search page used |
| `scrapedAt` | Collection timestamp |

Optional fields are omitted when Hemnet does not expose them on a result card.

### How to scrape current Hemnet listings

1. Open a public Hemnet current-listings search.
2. Apply the location and property filters you need.
3. Copy the result URL.
4. Paste it into **Hemnet search URLs**.
5. Set a low `maxItems` for your first run.
6. Click **Start**.
7. Export the default dataset.

Example input:

```json
{
  "startUrls": [
    { "url": "https://www.hemnet.se/till-salu/stockholms-kommun/stockholm" }
  ],
  "maxItems": 50,
  "maxPages": 2
}
````

### How to extract Hemnet sold prices

Provide a sold-search URL directly:

```json
{
  "startUrls": [
    { "url": "https://www.hemnet.se/salda/bostader?location_ids%5B%5D=18031" }
  ],
  "maxItems": 100
}
```

Or use a location ID and sold mode:

```json
{
  "locationIds": ["18031"],
  "mode": "sold",
  "maxItems": 100,
  "maxPages": 3
}
```

Sold rows can include both `askingPriceSek` and `finalPriceSek`, enabling sale-to-ask analysis.

### Current and sold market comparison

Set `mode` to `both` for location IDs:

```json
{
  "locationIds": ["18031"],
  "mode": "both",
  "maxItems": 250,
  "maxPages": 5
}
```

The resulting dataset distinguishes records using `status` while keeping comparable attributes in the same columns.

### Input reference

#### `startUrls`

An array of public `hemnet.se/till-salu/...` or `hemnet.se/salda/...` search URLs.

The Actor preserves query filters and controls only the `page` parameter.

#### `locationIds`

An optional array of numeric location IDs used by Hemnet.

Use this when a scheduled workflow should not depend on a long copied search URL.

#### `mode`

Controls location-ID searches only:

- `current` creates current-listing searches;
- `sold` creates sold-property searches;
- `both` creates one of each.

#### `maxItems`

Maximum unique records across all supplied searches.

The default is 100 and the maximum is 10,000.

#### `startPage`

Page number at which extraction begins.

This is useful for bounded backfills, but scheduled monitors should normally start at page 1.

#### `maxPages`

Maximum pages requested for each search.

This safety limit prevents an unexpectedly broad search from running indefinitely.

#### `proxyConfiguration`

Optional Apify Proxy settings.

Direct browser-grade HTTP is the low-cost default. If Hemnet blocks the run, configure a Swedish residential proxy session and retry a small input first.

### Output example

```json
{
  "propertyId": "9062587685407210462",
  "listingId": "21752338",
  "status": "sold",
  "address": "Tulegatan 21",
  "location": "Vasastan, Stockholms kommun",
  "housingType": "Lägenhet",
  "askingPriceSek": 4995000,
  "finalPriceSek": 6700000,
  "priceChangePercent": 34,
  "rooms": 1.5,
  "livingAreaM2": 44,
  "monthlyFeeSek": 2677,
  "pricePerM2Sek": 152273,
  "agencyName": "Erik Olsson Fastighetsförmedling",
  "latitude": 59.3434219,
  "longitude": 18.0608959,
  "detailUrl": "https://www.hemnet.se/salda/...",
  "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

### How much does it cost to scrape Hemnet properties?

This Actor uses pay-per-event pricing:

- one small **Start** charge per run;
- one **Property listing** charge per dataset row;
- automatic volume discounts by Apify plan.

You pay for produced property records rather than an idle monthly subscription.

Use low `maxItems` and `maxPages` values to validate a new search before scaling it.

The exact current prices appear in the Actor pricing tab and run estimate.

### Pagination and limits

Hemnet commonly exposes multiple result pages.

The Actor requests pages sequentially, stopping when any of these conditions is met:

- `maxItems` is reached;
- `maxPages` is reached;
- a result page contains no cards;
- a short final page indicates the end.

Sequential requests reduce pressure on the source and keep session behavior predictable.

### Data quality and normalization

Swedish non-breaking spaces, comma decimals, currency suffixes, and unit suffixes are removed before numeric conversion.

Examples:

- `14 995 000 kr` → `14995000`;
- `1,5 rum` → `1.5`;
- `44 m²` → `44`;
- `+34 %` → `34`.

Current and sold cards differ upstream, so each has an explicit adapter into the shared output model.

### Scheduling a Hemnet monitor

Apify schedules can run the Actor hourly, daily, or weekly.

A practical recurring workflow is:

1. save a narrowly filtered page-1 search;
2. set `maxPages` to 1 or 2;
3. schedule daily execution;
4. send dataset records to a webhook or automation;
5. deduplicate against your own historical listing ID store;
6. alert on newly observed homes or sold prices.

The `sourceUrl` and `scrapedAt` fields support audit and change-tracking logic.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to append current inventory or sold comparables for analyst review.

#### Make

Trigger a scenario after a run, filter by price or municipality, and send matches to email, Slack, or a CRM.

#### Zapier

Use new dataset items as automation events for lightweight property alerts.

#### Webhooks

Send a run-finished webhook to your data platform, then fetch the dataset through the API.

#### BigQuery or a warehouse

Export normalized numeric fields for trend analysis, broker share, price-per-square-meter distributions, and valuation features.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hemnet-swedish-real-estate-scraper').call({
  locationIds: ['18031'],
  mode: 'both',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/hemnet-swedish-real-estate-scraper').call(run_input={
    'locationIds': ['18031'],
    'mode': 'sold',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hemnet-swedish-real-estate-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locationIds":["18031"],"mode":"current","maxItems":50}'
```

Fetch dataset items after completion:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use with Apify MCP

Connect the Actor to AI assistants through:

`https://mcp.apify.com?tools=automation-lab/hemnet-swedish-real-estate-scraper`

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/hemnet-swedish-real-estate-scraper"
```

#### Claude Desktop setup

Add this to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify-hemnet": {
      "url": "https://mcp.apify.com?tools=automation-lab/hemnet-swedish-real-estate-scraper"
    }
  }
}
```

#### Cursor setup

Use the same `mcpServers` JSON in Cursor MCP settings and name the server `apify-hemnet`.

#### VS Code setup

Add the HTTP MCP URL to your VS Code MCP server configuration, then enable the `automation-lab/hemnet-swedish-real-estate-scraper` tool.

#### Example prompts

> Run the Hemnet Swedish Real Estate Scraper for location 18031 in sold mode. Summarize median final price and price per square meter by housing type.

> Extract 50 current Hemnet listings from this Stockholm search URL and identify properties with the lowest asking price per square meter.

MCP lets an assistant run the Actor and analyze the structured dataset without custom glue code.

### Tips for reliable runs

- Start with 10–20 items when validating a URL.
- Prefer specific search filters over very broad national searches.
- Keep scheduled monitors to the first recent pages.
- Use location IDs for stable recurring workflows.
- Enable proxy routing only when direct extraction is blocked.
- If using residential proxy, select Sweden and test minimal volume first.
- Store listing IDs in your downstream system for longitudinal deduplication.

### Troubleshooting

#### Why did the Actor reject my URL?

Only public Hemnet current and sold search URLs are accepted. A property detail URL or another hostname is rejected intentionally.

#### Why did the run fail with a blocked-page error?

Hemnet may vary access by network. Add an Apify Proxy configuration, preferably a Swedish session, and retry with a small item limit.

#### Why is `finalPriceSek` missing?

Final price is a sold-property field. Current listings usually expose only the asking price.

#### Why are some broker or coordinate fields absent?

The Actor exports fields available on each result card. Hemnet does not expose every optional attribute for every record.

#### Why did I receive fewer rows than `maxItems`?

`maxItems` is a ceiling, not a promise. The filtered search may contain fewer records, or `maxPages` may stop pagination earlier.

### Responsible use and legality

The Actor extracts public result-page information without logging into Hemnet.

You are responsible for complying with:

- Hemnet's applicable terms;
- copyright and database rights;
- GDPR and other privacy requirements;
- your legitimate purpose and retention rules;
- reasonable request volume.

Do not use the Actor to harass individuals, bypass access controls, or republish protected content unlawfully.

When personal names are present, assess your lawful basis before storing, enriching, or contacting anyone.

This documentation is not legal advice.

### Related real-estate scrapers

Explore other automation-lab tools for broader property workflows:

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) for US property data;
- [Booking Scraper](https://apify.com/automation-lab/booking-scraper) for accommodation market research;
- [Google Maps Lead Scraper](https://apify.com/automation-lab/google-maps-lead-scraper) for local broker and agency discovery.

Combine source-specific Actors downstream rather than assuming fields are identical across markets.

### FAQ

#### Does this scrape all of Sweden?

Yes, if you provide suitable Hemnet searches or location IDs and set sufficient limits. Begin with a narrow region to estimate volume and cost.

#### Can it scrape both listings and sold homes?

Yes. Paste URLs for each mode, or set `mode` to `both` when using location IDs.

#### Does it open every detail page?

No. It extracts rich structured result-card data. Avoiding detail-page requests keeps runs faster, cheaper, and gentler on the source.

#### Can I use existing Hemnet filters?

Yes. The Actor preserves query parameters from supplied search URLs while changing the page number during pagination.

#### Is a proxy required?

Not always. Direct browser-grade HTTP is the default. Proxy settings are available as a fallback for networks that receive blocks.

#### Can I export to CSV or Excel?

Yes. Use the dataset export controls in Apify Console or request another dataset format through the API.

#### Are prices returned as strings?

No. Price fields are normalized to numbers in SEK, making sorting and calculations straightforward.

#### Can this track price changes over time?

Schedule repeated runs and compare records by `propertyId` or `listingId` in your own storage. The Actor supplies observations; your downstream system maintains history.

### Support

If a public Hemnet result URL stops working, open an Actor issue with:

- the exact input, excluding secrets;
- the run ID;
- whether a proxy was enabled;
- the expected result type;
- one example of a missing or malformed record.

Reproducible details help us adapt quickly when Hemnet changes its page structure.

# Actor input Schema

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

Current (/till-salu/) or sold (/salda/) Hemnet result URLs. Existing URL filters are preserved.

## `locationIds` (type: `array`):

Optional numeric Hemnet location IDs, for example 18031 for Stockholms kommun.

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

Which result pages to create for location IDs. Search URLs always keep their own current/sold mode.

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

Stop after this many unique property records across all searches.

## `startPage` (type: `integer`):

First Hemnet result page to request.

## `maxPages` (type: `integer`):

Safety limit for pagination per supplied search.

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

Optional Apify Proxy settings. Start without a proxy; use Swedish residential sessions if your run is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.hemnet.se/till-salu/stockholms-kommun/stockholm"
    }
  ],
  "locationIds": [],
  "mode": "current",
  "maxItems": 20,
  "startPage": 1,
  "maxPages": 2
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.hemnet.se/till-salu/stockholms-kommun/stockholm"
        }
    ],
    "mode": "current",
    "maxItems": 20,
    "maxPages": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hemnet-swedish-real-estate-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 = {
    "startUrls": [{ "url": "https://www.hemnet.se/till-salu/stockholms-kommun/stockholm" }],
    "mode": "current",
    "maxItems": 20,
    "maxPages": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hemnet-swedish-real-estate-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 '{
  "startUrls": [
    {
      "url": "https://www.hemnet.se/till-salu/stockholms-kommun/stockholm"
    }
  ],
  "mode": "current",
  "maxItems": 20,
  "maxPages": 2
}' |
apify call automation-lab/hemnet-swedish-real-estate-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/hemnet-swedish-real-estate-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hemnet Swedish Real Estate Scraper",
        "description": "🏠 Extract current and sold Hemnet properties with normalized prices, areas, fees, brokers, dates, images, links, and coordinates for Swedish market research.",
        "version": "0.1",
        "x-build-id": "OtiDp0kAIdmn3pDfe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hemnet-swedish-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hemnet-swedish-real-estate-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/automation-lab~hemnet-swedish-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hemnet-swedish-real-estate-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/automation-lab~hemnet-swedish-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hemnet-swedish-real-estate-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": {
                    "startUrls": {
                        "title": "🔎 Hemnet search URLs",
                        "type": "array",
                        "description": "Current (/till-salu/) or sold (/salda/) Hemnet result URLs. Existing URL filters are preserved.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locationIds": {
                        "title": "Hemnet location IDs",
                        "type": "array",
                        "description": "Optional numeric Hemnet location IDs, for example 18031 for Stockholms kommun.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Location ID mode",
                        "enum": [
                            "current",
                            "sold",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which result pages to create for location IDs. Search URLs always keep their own current/sold mode.",
                        "default": "current"
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique property records across all searches.",
                        "default": 100
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "First Hemnet result page to request.",
                        "default": 1
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety limit for pagination per supplied search.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Start without a proxy; use Swedish residential sessions if your run is blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```