# ImmobilienScout24 Scraper - Germany Real Estate (`haketa/immobilienscout24-scraper`) Actor

ImmobilienScout24 scraper & API for German real estate: search apartments & houses for rent & buy and export price, m², rooms, energy class, address, GPS, agent-vs-private and price drops. Germany property market data and real-estate lead generation — fast, no login.

- **URL**: https://apify.com/haketa/immobilienscout24-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ImmobilienScout24 Scraper 🇩🇪 — Germany Real Estate Data (Rent & Buy)

Extract clean, structured real-estate data from **[ImmobilienScout24](https://www.immobilienscout24.de/)** — Germany's #1 property portal — without writing any code. Scrape **apartments and houses, for rent (mieten) and for sale (kaufen)** with full details: price, living space (m²), rooms, **energy class (Energieausweis)**, GPS coordinates, photos, agent contact, and — uniquely — **private-seller vs agency (Makler) detection** and **price-drop signals (Preissenkung)**.

This scraper is fast, cheap and **doesn't get blocked**: instead of fighting the website's aggressive bot protection (AWS WAF / Akamai / DataDome), it pulls data from ImmobilienScout24's **official mobile-app JSON API** — the same backend the IS24 iPhone/Android app uses. No CAPTCHAs, no headless browser, no silent empty results.

> 💡 **Why this actor?** Most IS24 scrapers either get blocked (empty rows, null prices) or are slow Playwright bots. This one uses the block-free mobile API for **reliable, complete data** — and adds lead-gen fields (private vs agency) and market signals (price drops) the others don't.

---

### 📋 Table of contents

- [What does it do?](#what-does-it-do)
- [Use cases](#use-cases)
- [How to use it](#how-to-use-it-step-by-step)
- [Input parameters](#input-parameters)
- [Input examples](#input-examples)
- [Output — data fields](#output--data-fields)
- [Sample output record](#sample-output-record)
- [Private vs agency & price drops](#private-vs-agency--price-drops)
- [Reliability — why it doesn't get blocked](#reliability--why-it-doesnt-get-blocked)
- [Tips & best practices](#tips--best-practices)
- [Frequently asked questions](#frequently-asked-questions)
- [Legal & responsible use](#legal--responsible-use)
- [Changelog](#changelog)

---

### What does it do?

ImmobilienScout24 lists **well over a million properties** across Germany. This actor turns any IS24 region search into a structured dataset you can download as **JSON, CSV, Excel, XML or HTML**, or pull from the **Apify API**.

You can scrape:

- ✅ **Apartments for rent** (Wohnung mieten)
- ✅ **Apartments for sale** (Wohnung kaufen)
- ✅ **Houses for rent** (Haus mieten)
- ✅ **Houses for sale** (Haus kaufen)
- ✅ **Any region** — a whole city, a district, or a wider area
- ✅ **Optional full detail** per listing: costs breakdown, year built, condition, heating, features, description, agent, and price-drop info

For every property you get **price, living space (Wohnfläche), rooms (Zimmer), energy efficiency class, full address with GPS coordinates, photos**, and whether the listing is from a **private owner (privater Anbieter) or a real-estate agent (Makler)**.

---

### Use cases

**🏢 Real-estate agents & brokers**
- Monitor competitors' listings, asking prices and inventory by city or district.
- Find **private sellers (FSBO)** to approach for new mandates.
- Track **price drops** to spot motivated sellers.

**📊 Market analysts & PropTech**
- Track **rent and price per m²** across cities and districts.
- Build automated valuation models and market reports.
- Analyse supply by property type, condition and energy efficiency.

**🎯 Lead generation & sales**
- Extract **agent name + company** for B2B outreach.
- Filter to **private sellers only** for off-market opportunities.
- Push leads into your CRM via the Apify API or integrations.

**🏦 Investors & developers**
- Screen entire cities for properties matching your criteria.
- Map listings by **GPS coordinates** for geographic analysis.
- Catch **reduced-price (Preissenkung)** listings early.

---

### How to use it (step by step)

No coding required.

1. Click **Try for free / Start**.
2. **Easiest method — paste a URL.** Open [immobilienscout24.de](https://www.immobilienscout24.de/), search for what you want (set the city/district and rent vs buy), then copy the URL from your browser into the **Search URLs** field. Example: `https://www.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten`.
3. **Or use the search builder.** Leave the URL field empty and set **Region** (e.g. `/de/bayern/muenchen`), **Rent or Buy**, and **Apartment or House**.
4. Set **Max items** (start with 100 for a test).
5. Keep **Scrape full listing details** on for the richest data (or turn it off for a faster, cheaper run).
6. Click **Save & Start**, then export the results as CSV, JSON, Excel, etc.

> 🔎 **Tip:** You can browse and search immobilienscout24.de normally in your own browser — only automated bots get blocked. So just search there, copy the URL, and paste it here.

---

### Input parameters

| Field | Type | Description |
|------|------|-------------|
| `startUrls` | array | IS24 search-result URLs (e.g. `.../Suche/de/berlin/berlin/wohnung-mieten`). Region + listing type are read from the URL. **When set, the builder fields are ignored.** |
| `geocodes` | string | Builder only. Region path as in IS24 URLs, e.g. `/de/berlin/berlin`, `/de/bayern/muenchen`. A numeric geocode ID also works. |
| `transactionType` | string | Builder only. `rent` (mieten) or `buy` (kaufen). |
| `propertyType` | string | Builder only. `apartment` (Wohnung) or `house` (Haus). |
| `maxItems` | integer | Max listings to scrape. `0` = no limit. Default `100`. |
| `includeDetails` | boolean | Fetch each listing's detail page for rich fields + price-drop detection. Default `true`. |
| `onlyPrivate` | boolean | Save only private-owner listings (skip agents). Default `false`. |
| `proxyConfiguration` | object | Proxy settings. Default: Apify Datacenter proxy (enough — the mobile API has no anti-bot). |
| `maxConcurrency` | integer | Max parallel requests. Default `8`. |

---

### Input examples

**1) Apartments for rent in Berlin (paste a browser URL)**

```json
{
  "startUrls": [
    { "url": "https://www.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten" }
  ],
  "maxItems": 500
}
````

**2) Houses for sale in Munich (search builder)**

```json
{
  "geocodes": "/de/bayern/muenchen",
  "transactionType": "buy",
  "propertyType": "house",
  "maxItems": 300
}
```

**3) Private sellers only, with full details (lead generation)**

```json
{
  "startUrls": [{ "url": "https://www.immobilienscout24.de/Suche/de/hamburg/hamburg/wohnung-kaufen" }],
  "onlyPrivate": true,
  "includeDetails": true,
  "maxItems": 200
}
```

**4) Fast, search-only run (no detail requests)**

```json
{
  "geocodes": "/de/berlin/berlin",
  "transactionType": "rent",
  "propertyType": "apartment",
  "includeDetails": false,
  "maxItems": 1000
}
```

***

### Output — data fields

Every scraped listing is one dataset record. Core fields (always present from the search):

| Field | Description |
|------|-------------|
| `id` | ImmobilienScout24 listing ID (Scout-ID) |
| `url` | Direct URL to the listing's expose page |
| `title` | Listing title |
| `realEstateType` | `apartmentrent`, `apartmentbuy`, `houserent`, `housebuy` |
| `price` | Numeric price (€) — rent or purchase price |
| `priceLabel` | Price as shown, e.g. `1.100 €` |
| `livingSpace` / `livingSpaceValue` | Living space, e.g. `46,6 m²` / `46.6` |
| `rooms` / `roomsValue` | Rooms, e.g. `2 Zi.` / `2` |
| `energyEfficiencyClass` | Energy class A+–H |
| `isPrivate` | `true` = private owner, `false` = agency |
| `advertiserType` | `private` or `agency` |
| `isNewObject` | Marked as a new listing |
| `isProject` | Part of a new-build project |
| `published` | Relative publish time (e.g. "vor 7 Monaten") |
| `address` | Full address line |
| `latitude` / `longitude` | GPS coordinates |
| `titlePicture` | Cover photo URL |
| `pictures` | Array of photo URLs |
| `listingType` | IS24 listing tier |
| `priceReduced` | `true` if the price was reduced (see below) |
| `scrapedAt` | ISO timestamp |

Extra fields when **`includeDetails` is on**:

| Field | Description |
|------|-------------|
| `baseRent` | Kaltmiete (cold rent) |
| `totalRent` | Warmmiete / Gesamtmiete (warm rent) |
| `serviceCharge` | Nebenkosten |
| `deposit` | Kaution |
| `pricePerSqm` | Price per m² |
| `bedrooms` / `bathrooms` | Schlafzimmer / Badezimmer |
| `floor` | Etage |
| `yearBuilt` | Baujahr |
| `condition` | Objektzustand |
| `interiorQuality` | Qualität der Ausstattung |
| `heatingType` | Heizungsart |
| `energySource` | Wesentliche Energieträger |
| `energyDemand` / `energyConsumption` | Endenergiebedarf / -verbrauch |
| `energyCertType` | Energieausweistyp |
| `availableFrom` | Bezugsfrei ab |
| `pets` | Haustiere |
| `features` | Array of amenities (balcony, lift, fitted kitchen, garden, …) |
| `description` | Full listing description text |
| `agentName` / `agentCompany` | Contact agent and company |
| `originalPrice` | Original price before reduction (if reduced) |
| `reductionPercentage` | Price reduction %, e.g. `-2 %` |
| `details` | Raw label→value dictionary of all detail attributes (German labels) |

> Fields that aren't provided for a given listing are returned as `null`/empty so your columns always stay aligned.

***

### Sample output record

```json
{
  "id": "163931526",
  "url": "https://www.immobilienscout24.de/expose/163931526",
  "title": "Erstbezug: 2 Zimmer Dachgeschoss mit großer Terrasse & Komplettküche",
  "realEstateType": "apartmentrent",
  "price": 1100,
  "priceLabel": "1.100 €",
  "livingSpace": "46,6 m²",
  "livingSpaceValue": 46.6,
  "rooms": "2 Zi.",
  "roomsValue": 2,
  "energyEfficiencyClass": "B",
  "isPrivate": false,
  "advertiserType": "agency",
  "address": "Adolf-Heyden-Straße 7, 12555 Berlin, Köpenick",
  "latitude": 52.44985,
  "longitude": 13.56565,
  "baseRent": "1.100 €",
  "totalRent": "1.263 €",
  "serviceCharge": "163 €",
  "yearBuilt": "2026",
  "condition": "Erstbezug",
  "heatingType": "Fernwärme",
  "features": ["Balkon/Terrasse", "Personenaufzug", "Einbauküche"],
  "agentName": "Herr Ronny Jäckel",
  "agentCompany": "MACANI Beteiligungs- und Entwicklungsgesellschaft mbH",
  "priceReduced": true,
  "originalPrice": "1.127,24 €",
  "reductionPercentage": "-2 %",
  "scrapedAt": "2026-06-04T12:00:00.000Z"
}
```

***

### Private vs agency & price drops

Two things this actor surfaces that most don't:

- **Private vs agency (Makler):** `isPrivate: true` marks a **private owner** — gold for agents hunting new mandates and for renters/buyers who want to avoid agency commission. Set **`onlyPrivate: true`** to get a clean private-seller list.
- **Price drops (Preissenkung):** when a listing's price was reduced, `priceReduced` is `true` and you get `originalPrice` and `reductionPercentage`. Reduced-price listings often mean **motivated sellers** — a strong signal for buyers and investors.

***

### Reliability — why it doesn't get blocked

The ImmobilienScout24 **website** is protected by AWS WAF / Akamai / DataDome. Browser-based scrapers hitting the website hit CAPTCHAs and frequently return **silent empty rows (null price/area/rooms)** — the #1 complaint about IS24 scrapers.

This actor avoids that entirely by using the **official mobile-app JSON API** (`api.mobile.immobilienscout24.de`), which:

- Has **no anti-bot challenge, no CAPTCHA, no login**.
- Returns **clean structured JSON** — fast and complete.
- Needs **no headless browser**, so runs are cheap and quick.

Apify Datacenter proxies are enabled by default mainly to rotate IPs and avoid rate limits on large runs.

***

### Tips & best practices

- 🔗 **Prefer pasting a browser URL** — it captures the exact region and listing type with zero guesswork.
- 🧪 **Start with `maxItems: 50`** to confirm the output, then scale up.
- ⚡ **Turn off `includeDetails`** for the fastest, cheapest runs when you only need core fields (price, m², rooms, address, energy class).
- 🧱 **Split big cities by district** for very large coverage and better throughput.
- 💾 **Use the Apify API / integrations** to push results into Google Sheets, a database, or a webhook.
- 🔁 **Schedule runs** to track new listings and price drops over time.

***

### Frequently asked questions

**Is scraping ImmobilienScout24 legal?**
This actor collects **publicly available** listing data. You are responsible for how you use it — respect GDPR, don't misuse personal data, and review IS24's terms. See [Legal & responsible use](#legal--responsible-use).

**Why didn't my run return results?**
Check that your Start URL is a `/Suche/...` search URL with a region and a type slug (`wohnung-mieten`, `wohnung-kaufen`, `haus-mieten`, `haus-kaufen`), or that your builder `geocodes` path is valid (copy it from an IS24 URL).

**Can I scrape sold prices?**
No — ImmobilienScout24 doesn't publish sold/transaction prices. This actor covers **active listings**. It does, however, detect **price reductions** on active listings.

**Can I get phone numbers?**
The mobile API exposes the agent's **name and company**; phone numbers are usually gated behind a contact action and are often not present.

**What about Austria (.at) and Switzerland (.ch)?**
This version targets **Germany (immobilienscout24.de)**. Other markets may be added later.

**What export formats are supported?**
JSON, CSV, Excel, XML, HTML table, RSS — plus the Apify API and integrations (Google Sheets, Make, Zapier, webhooks, etc.).

***

### Legal & responsible use

This tool is intended for lawful purposes such as market research, competitor analysis and lead generation on **publicly available** data. You are solely responsible for ensuring your use complies with applicable laws (including **GDPR** when personal data is involved), ImmobilienScout24's terms of service, and any contractual obligations. Do not use the data for spam, harassment, or any unlawful purpose. When in doubt, consult a legal professional.

***

### Changelog

**0.1.0**

- Initial release: apartments & houses, rent & buy, via the block-free mobile JSON API.
- Search by pasted URL or region builder; automatic pagination.
- Core fields + optional rich detail (costs, year built, condition, heating, energy, features, description, agent).
- Private-vs-agency detection, `onlyPrivate` filter, and price-drop (Preissenkung) detection.

***

*Not affiliated with, endorsed by, or connected to ImmobilienScout24 or Immobilien Scout GmbH. All trademarks belong to their respective owners.*

# Actor input Schema

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

Paste one or more immobilienscout24.de search-result URLs from your browser (e.g. https://www.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten). The actor reads the region and listing type straight from the URL. When provided, the search builder fields below are ignored. This is the recommended way to scrape exactly what you searched for.

## `geocodes` (type: `string`):

Search builder only (used when no Start URLs are given). The region as it appears in immobilienscout24.de URLs after /Suche/, e.g. '/de/berlin/berlin', '/de/bayern/muenchen', '/de/hamburg/hamburg'. A numeric geocode ID also works.

## `transactionType` (type: `string`):

Search builder only.

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

Search builder only.

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

Maximum number of listings to scrape across all searches. Use 0 for no limit (large cities can have thousands).

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

Fetch each listing's detail page (one extra request per listing) to add Warmmiete/Nebenkosten, year built, condition, heating, full feature list, description, agent contact and PRICE-DROP detection. Disable for a faster, cheaper, search-only run.

## `onlyPrivate` (type: `boolean`):

Save only listings from private owners (privater Anbieter), skipping real-estate agents (Makler). Ideal for off-market lead generation.

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

The mobile API has no anti-bot, so rotating Apify Datacenter proxies are enough (and cheap). Proxies mainly help avoid rate limits on large runs.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten"
    }
  ],
  "geocodes": "/de/berlin/berlin",
  "transactionType": "rent",
  "propertyType": "apartment",
  "maxItems": 100,
  "includeDetails": true,
  "onlyPrivate": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8
}
```

# Actor output Schema

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

All listings collected during the run.

## `runUrl` (type: `string`):

Open this run in the Apify Console.

# 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.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/immobilienscout24-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.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/immobilienscout24-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.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/immobilienscout24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ImmobilienScout24 Scraper - Germany Real Estate",
        "description": "ImmobilienScout24 scraper & API for German real estate: search apartments & houses for rent & buy and export price, m², rooms, energy class, address, GPS, agent-vs-private and price drops. Germany property market data and real-estate lead generation — fast, no login.",
        "version": "0.1",
        "x-build-id": "Id5rL2j1hy6xzv3Tb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~immobilienscout24-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-immobilienscout24-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/haketa~immobilienscout24-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-immobilienscout24-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/haketa~immobilienscout24-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-immobilienscout24-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": "Search URLs",
                        "type": "array",
                        "description": "Paste one or more immobilienscout24.de search-result URLs from your browser (e.g. https://www.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten). The actor reads the region and listing type straight from the URL. When provided, the search builder fields below are ignored. This is the recommended way to scrape exactly what you searched for.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "geocodes": {
                        "title": "Region (geocode path or ID)",
                        "type": "string",
                        "description": "Search builder only (used when no Start URLs are given). The region as it appears in immobilienscout24.de URLs after /Suche/, e.g. '/de/berlin/berlin', '/de/bayern/muenchen', '/de/hamburg/hamburg'. A numeric geocode ID also works.",
                        "default": "/de/berlin/berlin"
                    },
                    "transactionType": {
                        "title": "Rent or Buy",
                        "enum": [
                            "rent",
                            "buy"
                        ],
                        "type": "string",
                        "description": "Search builder only.",
                        "default": "rent"
                    },
                    "propertyType": {
                        "title": "Apartment or House",
                        "enum": [
                            "apartment",
                            "house"
                        ],
                        "type": "string",
                        "description": "Search builder only.",
                        "default": "apartment"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape across all searches. Use 0 for no limit (large cities can have thousands).",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Scrape full listing details",
                        "type": "boolean",
                        "description": "Fetch each listing's detail page (one extra request per listing) to add Warmmiete/Nebenkosten, year built, condition, heating, full feature list, description, agent contact and PRICE-DROP detection. Disable for a faster, cheaper, search-only run.",
                        "default": true
                    },
                    "onlyPrivate": {
                        "title": "Only private sellers (skip agencies)",
                        "type": "boolean",
                        "description": "Save only listings from private owners (privater Anbieter), skipping real-estate agents (Makler). Ideal for off-market lead generation.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "The mobile API has no anti-bot, so rotating Apify Datacenter proxies are enough (and cheap). Proxies mainly help avoid rate limits on large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum parallel requests.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```