# Oikotie Scraper - Finnish Real Estate Listings (`studio-amba/oikotie-scraper`) Actor

Scrape real estate listings from Oikotie.fi — Finland's #1 property portal with 55,000+ active listings. Get prices, addresses, property details, rooms, surface area, and images for apartments and houses. Supports sale and rental listings. No login or cookies required.

- **URL**: https://apify.com/studio-amba/oikotie-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Oikotie Scraper

Scrape **real estate listings from Oikotie.fi** — Finland's largest and most popular property portal with over 55,000 active listings. Extract prices, addresses, property details, room configurations, surface area, and images. No login or cookies required.

### What does Oikotie Scraper do?

This actor extracts structured data from [Oikotie.fi](https://asunnot.oikotie.fi), Finland's #1 real estate marketplace used by millions of Finns to find apartments and houses. It scrapes listing search results and returns clean, structured JSON data including asking prices, property types, room counts, surface area, build year, and images. Run it via the Apify API, schedule recurring scrapes, or integrate with 1,000+ apps through Apify's built-in integrations.

### How to scrape Oikotie data

1. Click **Try for free** to open the actor in Apify Console
2. Enter a Finnish city name (e.g., `Helsinki`, `Tampere`, `Espoo`)
3. Choose listing type: **For Sale** or **For Rent**
4. Optionally filter by property type, price range, or max results
5. Click **Start** to run the scraper
6. Download your data as JSON, CSV, Excel, or connect via API

### Why use Oikotie Scraper?

- **Real estate market research** — Track Finnish property prices, trends, and inventory across cities and districts
- **Investment analysis** — Compare asking prices and price per m2 across Helsinki, Tampere, Turku, and other Finnish cities
- **Competitive intelligence** — Monitor listing volumes, pricing patterns, and market supply for real estate agencies
- **Data journalism** — Build datasets for Finnish housing market reporting
- **Academic research** — Study housing affordability, urban development, and market dynamics in Finland
- **Rental market monitoring** — Track rental prices across Finnish cities and neighborhoods
- **Property development** — Identify undervalued areas and emerging neighborhoods

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | City or area to search (default: `Helsinki`). Examples: `Tampere`, `Espoo`, `Turku`, `Oulu`, `Jyvaskyla` |
| `listingType` | String | No | `sale` (myytavat) or `rent` (vuokra). Default: `sale` |
| `propertyType` | String | No | Filter: `kerrostalo` (apartment), `omakotitalo` (detached house), `rivitalo` (terraced house), `paritalo` (semi-detached) |
| `minPrice` | Integer | No | Minimum price in EUR |
| `maxPrice` | Integer | No | Maximum price in EUR |
| `maxResults` | Integer | No | Maximum listings to return (default: 100) |
| `proxyConfiguration` | Object | No | Proxy settings. Finnish residential proxies recommended. |

#### Supported cities

All Finnish cities and municipalities are supported. Popular searches include: Helsinki, Espoo, Tampere, Vantaa, Turku, Oulu, Jyvaskyla, Lahti, Kuopio, Pori, Kouvola, Joensuu, Lappeenranta, Hameenlinna, Rovaniemi, Vaasa, Seinajoki, Mikkeli, Kotka, Salo, Porvoo, and Kokkola.

#### Property types (Finnish)

| Finnish | English |
|---------|---------|
| `kerrostalo` | Apartment building |
| `omakotitalo` | Detached house |
| `rivitalo` | Terraced house / row house |
| `paritalo` | Semi-detached house |
| `erillistalo` | Detached house (alternate) |
| `luhtitalo` | Gallery-access apartment |

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `title` | String | `"Mannerheimintie 15, 2h+k, 55 m2"` |
| `price` | Number | `245000` |
| `currency` | String | `"EUR"` |
| `listingType` | String | `"sale"` |
| `propertyType` | String | `"kerrostalo"` |
| `address` | String | `"Mannerheimintie 15"` |
| `city` | String | `"Helsinki"` |
| `postalCode` | String | `"00100"` |
| `district` | String | `"Kamppi"` |
| `rooms` | Number | `2` |
| `surface` | Number | `55` |
| `buildYear` | Number | `1962` |
| `condition` | String | `"Hyvä"` |
| `imageUrl` | String | Primary listing image URL |
| `imageUrls` | Array | All listing image URLs |
| `url` | String | Full listing URL on Oikotie |
| `scrapedAt` | String | ISO 8601 timestamp |
| `agencyName` | String | Real estate agency name |

### Example output

```json
{
    "title": "Mannerheimintie 15, 2h+k, 55 m2",
    "price": 245000,
    "currency": "EUR",
    "listingType": "sale",
    "propertyType": "kerrostalo",
    "address": "Mannerheimintie 15",
    "city": "Helsinki",
    "postalCode": "00100",
    "district": "Kamppi",
    "latitude": null,
    "longitude": null,
    "rooms": 2,
    "surface": 55,
    "buildYear": 1962,
    "condition": null,
    "imageUrl": "https://images.oikotie.fi/...",
    "imageUrls": ["https://images.oikotie.fi/..."],
    "description": "",
    "agencyName": "",
    "url": "https://asunnot.oikotie.fi/myytavat-asunnot/helsinki/12345678",
    "scrapedAt": "2026-05-27T12:00:00.000Z"
}
````

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### How much does it cost to scrape Oikotie?

This actor uses approximately **0.5-1.0 compute units per 100 results** (Playwright-based rendering). At standard Apify pricing, scraping 1,000 listings costs roughly **$2.50-$5.00**. The free Apify tier gives you enough credits to scrape several hundred listings per month.

Residential proxies with Finnish IP addresses are recommended for reliable results. These use Apify's residential proxy pool.

### Tips

- **Use Finnish residential proxies** for best reliability — set proxy country to `FI` in advanced settings
- **Filter by property type** to get more targeted results and reduce processing time
- **Start with a small maxResults** (e.g., 20) to verify the output before running large scrapes
- **Schedule daily runs** to track new listings and price changes over time
- **Combine with the Apify API** to build automated Finnish real estate monitoring pipelines
- **Use city-level searches** rather than broad national queries for faster, more targeted results

### Limitations

- Some detail fields (description, agency, coordinates) may not be available from search result cards
- Oikotie.fi is a JavaScript-rendered SPA — this actor uses Playwright for full rendering
- The site may occasionally show cookie consent modals; the scraper handles these automatically
- Data is scraped from the public website and may change without notice
- This actor does not require login or cookies to operate

### FAQ

**Is it legal to scrape Oikotie?**
Web scraping of publicly available data is generally permitted. This actor only accesses publicly visible information that any browser user can see. Always review Oikotie's terms of service and applicable Finnish/EU data protection regulations for your specific use case.

**Can I scrape rental listings?**
Yes. Set the `listingType` input parameter to `rent` to scrape rental listings from Oikotie's vuokra-asunnot section.

**What if I get empty results?**
Check the `debug-page-html` key in the key-value store. The site may have changed its structure or your proxy may need adjustment. Try using Finnish residential proxies.

**Need a custom solution?**
Open an issue on the Issues tab or contact us through Apify. We can build custom scrapers for specific Finnish real estate data needs.

# Actor input Schema

## `searchQuery` (type: `string`):

City or area to search (e.g., 'Helsinki', 'Tampere', 'Espoo', 'Turku'). Used as the location path in the URL.

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

Type of listings to scrape.

## `propertyType` (type: `string`):

Filter by property type.

## `minPrice` (type: `integer`):

Minimum price in EUR.

## `maxPrice` (type: `integer`):

Maximum price in EUR.

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

Maximum number of listings to return.

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

Proxy settings. Residential proxies with FI country recommended for best results.

## Actor input object example

```json
{
  "searchQuery": "Helsinki",
  "listingType": "sale",
  "propertyType": "",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FI"
  }
}
```

# 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 = {
    "searchQuery": "Helsinki",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FI"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/oikotie-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 = {
    "searchQuery": "Helsinki",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FI",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/oikotie-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 '{
  "searchQuery": "Helsinki",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FI"
  }
}' |
apify call studio-amba/oikotie-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Oikotie Scraper - Finnish Real Estate Listings",
        "description": "Scrape real estate listings from Oikotie.fi — Finland's #1 property portal with 55,000+ active listings. Get prices, addresses, property details, rooms, surface area, and images for apartments and houses. Supports sale and rental listings. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "G8138C5npQxOgbbTh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~oikotie-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-oikotie-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/studio-amba~oikotie-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-oikotie-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/studio-amba~oikotie-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-oikotie-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": {
                    "searchQuery": {
                        "title": "Search Query / City",
                        "type": "string",
                        "description": "City or area to search (e.g., 'Helsinki', 'Tampere', 'Espoo', 'Turku'). Used as the location path in the URL.",
                        "default": "Helsinki"
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Type of listings to scrape.",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "kerrostalo",
                            "omakotitalo",
                            "rivitalo",
                            "paritalo",
                            "erillistalo",
                            "luhtitalo"
                        ],
                        "type": "string",
                        "description": "Filter by property type.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in EUR."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in EUR."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies with FI country recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
