# Complete Guide: How to Scrape ImmoScout24 Listings Using Python

This complete guide shows how to scrape ImmoScout24 listings from Python with the Apify Actor **ImmoScout24 Scraper** (`reventadata/immobilienscout24-scraper`). You will end with typed rows for apartments to rent, apartments to buy and houses to buy for a state and city pair of slugs copied from a search address: price, living space, rooms, address, coordinates, energy class, feature tags, photos and the agent's published contact details.

The portal is hard to read in bulk. A capture of the Berlin rent search dated 2026-11-07 reports 13,833 hits over 662 result pages of 20 cards each. With the Actor, you only write the Python that starts it and reads the dataset.

> **Unofficial.** This Actor is not affiliated with, endorsed by or connected to ImmoScout24 or Scout24.

---

## TL;DR

In this tutorial you will learn to configure the ImmoScout24 Scraper from Python, start a run, check its status, read the dataset and rank Berlin rentals by rent per square metre. The key steps: install `apify-client`, export `APIFY_API_TOKEN`, describe the search in `run_input`, call the Actor, then loop over the items in `run.default_dataset_id`. The expected outcome is a list of listings as JSON, ready for a spreadsheet or database. The Actor is at [apify.com/reventadata/immobilienscout24-scraper](https://apify.com/reventadata/immobilienscout24-scraper).

---

## Prerequisites and setup

You need three things: Python 3.11 or newer (`apify-client` 3.x requires it), a free Apify account, and an API token. You do not need a browser, a proxy list or any scraping library, because the Actor handles fetching and parsing. Reading the output needs nothing beyond the standard library. Apify Console is the web app where runs, datasets and tokens live; the token is on the **API & Integrations** page. The platform documentation index is at [docs.apify.com](https://docs.apify.com/).

Install the Python client:

```bash
pip install -U "apify-client~=3.0"
```

Export the token so it stays out of your source:

```bash
export APIFY_API_TOKEN="your_apify_token_here"
```

---

## Understanding ImmoScout24 Scraper

The Actor never opens individual listing pages. Each result page holds 20 listing cards. The first page is requested without a page parameter; later pages follow the next-page link the site itself publishes, and the Actor only accepts that link when it stays on the same search path with parameters it knows. What it offers:

- **Three search kinds:** apartments to rent (`wohnung-mieten`), apartments to buy (`wohnung-kaufen`) and houses to buy (`haus-kaufen`), each for a state and city pair.
- **Two ways in:** a place (state, city, rent or buy, apartment or house) or one or more pasted search addresses.
- **Numeric limits** on price, living space and rooms, applied after fetching.
- **Seller data** as the listing publishes it: company, contact name, phone and mobile number.
- **Grouped listings:** the other units of a new-build project are returned as their own rows.

Limits to know: districts inside a city, national searches and houses for rent are not offered. Houses for rent pass the input form, because `rent` and `house` are each valid, but the Actor stops with a message that says so.

---

## Step-by-step walkthrough

### Step 1: Open the Actor

Open the [ImmoScout24 Scraper](https://apify.com/reventadata/immobilienscout24-scraper) page on Apify Store to read its input fields. In this guide we call it from Python, so the only thing you need from the page is the name `reventadata/immobilienscout24-scraper`.

### Step 2: Describe the search

Create the client and the input. State and city are the two slugs from a search address (`berlin` and `berlin`, `bayern` and `muenchen`, `hessen` and `frankfurt-am-main`). `listingType` and `propertyType` are enums, and a value outside their lists is refused before the run starts:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_API_TOKEN"])

run_input = {
    "state": "berlin",
    "city": "berlin",
    "listingType": "rent",
    "propertyType": "apartment",
    "maxPrice": 1500,
    "minLivingSpaceM2": 50,
    "includeGroupedListings": False,
    "maxItems": 50,
    "maxPages": 3,
}
```

`maxPrice` and `minLivingSpaceM2` drop rows after they are fetched, and a row without the value is dropped too. `maxItems` caps rows saved; `maxPages` caps pages walked per search. Or pass a search address in `startUrls`:

```python
run_input = {
    "startUrls": [
        {"url": "https://www.immobilienscout24.de/Suche/de/berlin/berlin/wohnung-mieten?price=1000.0-1500.0&livingspace=50.0-80.0"}
    ],
    "includeGroupedListings": False,
    "maxPages": 2,
}
```

### Step 3: Start the run and fetch the items

`call()` starts the Actor and waits for the run to end. The client returns a typed `Run`, so read `run.status` and `run.default_dataset_id`:

```python
run = client.actor("reventadata/immobilienscout24-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} listings.\n")
```

### Step 4: Read the rows

```python
for item in items:
    size = f'{item.get("livingSpaceM2")} m²' if item.get("livingSpaceM2") else "size not stated"
    print(f'{item.get("price")} {item.get("currency")} | {size} | {item.get("rooms")} rooms | {item.get("postcode")} {item.get("quarter")}')
    print(f'  {item.get("title")}')
    print(f'  {item.get("url")}')
    phone = item.get("contactPhone") or item.get("contactMobile") or "no phone published"
    print(f'  {item.get("realtorCompanyName") or "no company shown"} | {phone}')
```

### Step 5: Look at one row

This is one row from the sample rows from a run on 2026-11-10 (Hamburg apartments to rent, `minRooms: 2`, `maxPrice: 1500`), with the `photos` list shortened to two entries:

```json
{
    "id": "171310471",
    "url": "https://www.immobilienscout24.de/expose/171310471",
    "listingType": "rent",
    "propertyType": "apartment",
    "realEstateType": "ApartmentRent",
    "title": "Erstbezug nach DG-Neuaufbau – Wunderbare - 2 -Zimmer-Wohnung zu vermieten",
    "street": "Kurvenstr.",
    "houseNumber": "10d",
    "postcode": "22043",
    "city": "Hamburg",
    "quarter": "Marienthal",
    "locationText": "Kurvenstr. 10d, Marienthal, Hamburg",
    "latitude": 53.56681,
    "longitude": 10.07373,
    "hasPreciseAddress": true,
    "price": 1015,
    "currency": "EUR",
    "priceInterval": "MONTH",
    "totalRent": 1135,
    "livingSpaceM2": 45.26,
    "plotAreaM2": null,
    "rooms": 2,
    "constructionYear": 1948,
    "hasBalcony": false,
    "hasBuiltInKitchen": true,
    "hasGarden": false,
    "hasLift": null,
    "hasCellar": null,
    "hasGuestToilet": null,
    "isBarrierFree": null,
    "hasBuyerCommission": null,
    "energyEfficiencyClass": "A+",
    "hasEnergyCertificate": true,
    "fairPriceRating": null,
    "isPrivateOffer": false,
    "hasFloorplan": true,
    "hasVideo": false,
    "hasVirtualTour": null,
    "features": [
        "Einbauküche",
        "Keller"
    ],
    "realtorCompanyName": "Voigt und König Immobilienverwaltungs GmbH",
    "realtorId": "136907945",
    "contactSalutation": "MALE",
    "contactFirstName": "F. König - ",
    "contactLastName": "Voigt und König Immobilienverwaltungs GmbH ",
    "contactCompany": "Voigt und König Immobilienverwaltungs GmbH",
    "contactPhone": "040 89979767",
    "contactMobile": null,
    "photos": [
        "https://pictures.immobilienscout24.de/listings/ae6fc300-863f-40cf-a61c-9960081c2359-2126632276.png/ORIG/legacy_thumbnail/800x600/format/webp/quality/50",
        "https://pictures.immobilienscout24.de/listings/36cc0971-ab59-4aa9-952f-f4f38ee45a9f-2126632282.png/ORIG/legacy_thumbnail/800x600/format/webp/quality/50"
    ],
    "floorplans": [],
    "projectId": null,
    "projectName": null,
    "projectUrl": null,
    "groupedUnderId": null,
    "publishedAt": "2026-11-08T17:47:08.000+01:00",
    "createdAt": "2026-11-08T17:47:08.000+01:00",
    "modifiedAt": "2026-11-08T17:48:02.559+01:00",
    "searchUrl": "https://www.immobilienscout24.de/Suche/de/hamburg/hamburg/wohnung-mieten",
    "scrapedAt": "2026-11-10T19:52:32+00:00"
}
```

---

## Working with the API

Everything above is the API: `ApifyClient` authenticates with your token, `client.actor(...).call(run_input=...)` starts a run with the input as JSON, and `client.dataset(run.default_dataset_id).list_items().items` returns the rows. The token comes from your account (**API & Integrations** in Apify Console) and belongs in an environment variable, never in a repository.

Check `run.status` before reading rows, and treat `run.default_dataset_id` as the handle to the output: the dataset belongs to that run and holds every row it saved. A run that saves nothing because pages could not be read ends FAILED with a status message, and a search the site answers with zero hits ends SUCCEEDED with an empty dataset and a message that says nothing matched. Treating both as "no rows" hides the difference, so the script above stops on anything that is not `SUCCEEDED` and prints the status it saw. If you want the zero-hit case to count as a normal answer, handle it explicitly rather than by accident.

To repeat a search on a timer, save it as a task and attach an [Apify schedule](https://docs.apify.com/actors/running/schedules), which runs an Actor on a cron expression. The full client reference is in the [Python client docs](https://docs.apify.com/api/client/python/), including how to start a run without waiting for it.

---

## Advanced usage patterns

**Let the site filter.** Build the search in your browser, copy the address and pass it in `startUrls` as shown in Step 2 above, instead of setting numeric limits in the input object. The site's own `price`, `livingspace`, `numberofrooms` and `sorting` filters then decide what is fetched before the Actor reads a page. A price-filtered rent search makes the site add a `pricetype` parameter to its next-page link; the Actor accepts it.

**Several searches in one run.** `startUrls` takes a list. The searches run one after another and `maxItems` is a cap across all of them, so a rent URL and a buy URL can share one run.

**Grouped listings.** `includeGroupedListings` is on by default. Page 1 of the Berlin rent capture holds 20 cards and 205 grouped units, 225 rows from one page. Set it to `False`, as above, to keep the cards only, or keep it on and use `groupedUnderId` to group the units yourself. Either way the card and its units share the same row shape.

**Rank the results.** This sorts the rows from the run above by rent per square metre:

```python
priced = [i for i in items if i.get("price") and i.get("livingSpaceM2")]
priced.sort(key=lambda i: i["price"] / i["livingSpaceM2"])
for i in priced[:5]:
    print(f'{i["price"] / i["livingSpaceM2"]:.1f} EUR/m² | {i["url"]}')
```

---

## Understanding your data

The sample row shows the schema. The fields that need a note:

- `price` is the base rent per month on rent searches (`priceInterval` is `MONTH`) and the purchase price on buy searches (`ONE_TIME_CHARGE`). `totalRent` is the calculated total rent when the site shows one.
- `livingSpaceM2`, `rooms` and, for houses, `plotAreaM2` are numbers.
- Yes/no fields (`hasBalcony`, `hasLift`, `hasCellar`, `hasGuestToilet`, `isBarrierFree`, `hasBuyerCommission`) are `null` when the listing does not say.
- `latitude` and `longitude` come with `hasPreciseAddress: true`, along with `street` and `houseNumber`; 19 of the 20 cards in the capture carry coordinates.
- `contactPhone` and `contactMobile` are what the seller published in the results list; 8 of the 20 cards carry one.
- `projectId`, `projectName` and `projectUrl` describe a new-build project; `groupedUnderId` is `null` on a card.
- `publishedAt`, `createdAt` and `modifiedAt` are the site's timestamps; `searchUrl` is the search the row came from and `scrapedAt` is when the run read the page.
- `url` opens the listing on the site.

---

## Troubleshooting guide

- **Empty dataset, run SUCCEEDED.** The site answered but nothing matched, or your limits dropped every row. The status message says so; loosen `maxPrice` or `minLivingSpaceM2`.
- **Run FAILED, slug message.** With no rows saved, the state or city slug does not exist for that search kind (after earlier rows, it logs a warning). Copy both slugs from a search address.
- **Run FAILED, URL message.** A pasted address with another path, a district, or a parameter outside `price`, `livingspace`, `numberofrooms`, `sorting` and `pricetype` is refused with a message that names the problem. A `pagenumber` in a pasted address is dropped, because the Actor paginates itself.
- **Fewer rows than the site's count.** The site's count includes grouped units and can shift by a listing or two between requests, ids that repeat across pages are saved once, and your limits drop rows.
- **A price of 0.** In the capture, 2 of the 29 rows on the Berlin houses-for-sale page 2 carry a price of 0 in the site's data, and the Actor passes it on. Set `minPrice` to 1 to drop them.
- **Reading the log.** The closing lines are `Skipped N: reason` for dropped rows and `Pushed N row(s).`.

---

## Best practices

Start with `maxPages: 1` and `maxItems: 20`: the input description warns that a page can take 15 to 45 seconds, and your first goal is to see the fields. Prefer URL filters over the numeric inputs when you can, because the site then returns fewer pages. Decide on `includeGroupedListings` before a large run, since it multiplies the rows per page. Keep the token in the environment, and key your own storage on `id`, which is the listing id in the address `https://www.immobilienscout24.de/expose/<id>`. Expect gaps: a field the seller left out is `null`, so code that reads a row should test for `None` before it does arithmetic, as the rent-per-square-metre snippet does by requiring a price and a living space.

---

## Pricing model

For current pricing and details, see the [Store page](https://apify.com/reventadata/immobilienscout24-scraper).

---

## Conclusion and next steps

You now have a script that turns an ImmoScout24 search into JSON rows and ranks them. From here, try a buy search, pass a filtered address, or put the call on a schedule. Try the Actor yourself and let me know what you build.

*About the author: reventadata builds web scraping Actors for the Apify Store.*

---

## Resources

- [ImmoScout24 Scraper on Apify Store](https://apify.com/reventadata/immobilienscout24-scraper)
- [Apify Python client documentation](https://docs.apify.com/api/client/python/)
- [Apify schedules](https://docs.apify.com/actors/running/schedules)
