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.

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.
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:
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:
priceis the base rent per month on rent searches (priceIntervalisMONTH) and the purchase price on buy searches (ONE_TIME_CHARGE).totalRentis the calculated total rent when the site shows one.livingSpaceM2,roomsand, for houses,plotAreaM2are numbers.- Yes/no fields (
hasBalcony,hasLift,hasCellar,hasGuestToilet,isBarrierFree,hasBuyerCommission) arenullwhen the listing does not say. latitudeandlongitudecome withhasPreciseAddress: true, along withstreetandhouseNumber; 19 of the 20 cards in the capture carry coordinates.contactPhoneandcontactMobileare what the seller published in the results list; 8 of the 20 cards carry one.projectId,projectNameandprojectUrldescribe a new-build project;groupedUnderIdisnullon a card.publishedAt,createdAtandmodifiedAtare the site's timestamps;searchUrlis the search the row came from andscrapedAtis when the run read the page.urlopens 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
maxPriceorminLivingSpaceM2. - 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,sortingandpricetypeis refused with a message that names the problem. Apagenumberin 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
minPriceto 1 to drop them. - Reading the log. The closing lines are
Skipped N: reasonfor dropped rows andPushed 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
Comments
Join the discussionNo comments yet. Be the first to comment.




