Skip to main content

Complete Guide: How to Scrape ImmoScout24 Listings Using Python

Call the ImmoScout24 Scraper Apify Actor from Python and get German rent and buy listings with prices, areas, agents and phones as clean JSON.

Updated 10 min readMarkdown
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.


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.

Install the Python client:

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

Export the token so it stays out of your source:

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

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:

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:

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:

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

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:

{
    "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, which runs an Actor on a cron expression. The full client reference is in the Python client docs, 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:

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.


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

About the author

  • Hi, I'm the engineer behind ReventaData. I build pay-per-event Apify Actors that turn public marketplace, classifieds, jobs and real-estate sites into clean, reliable datasets. Here on Hashnode, I share practical tutorials on collecting structured web data with Python and Apify, and on putting it to work: price tracking, lead lists and market analysis. Explore our turnkey scrapers: https://apify.com/reventadata

No comments yet. Be the first to comment.