# Complete Guide: How to Scrape Immowelt Listings Using Python

Immowelt is a German real-estate portal with listings for sale and for rent. This guide shows how to pull those listings into structured rows with Python, using the **Immowelt Scraper** Apify Actor (`reventadata/immowelt-scraper`). You describe a search, the Actor reads the public search pages, and it returns one row per listing with price, size, rooms, district, energy class where published, the agency and the phone numbers the agency published.

The sample rows in this guide come from one example run of the Actor on 18 November 2026: ten apartments for sale in Berlin, taken from the first page of the search. The sample row is copied from the run's dataset, with its photo list cut to one entry.

By the end you will know which inputs the Actor accepts, what a row contains, where the limits are, and how to handle a run that returns fewer rows than you expected. The prerequisites are minimal: Python 3, an Apify account and an API token.

---

## TL;DR

- Install `apify-client`, set `APIFY_API_TOKEN`, and call the Actor with a small input.
- The input fields are `transaction`, `propertyType`, `location`, `maxPrice`, `sortBy`, `includeAuctions`, `maxItems` and `maxPages`.
- Each listing is one row with 45 fields, including `price`, `areaM2`, `rooms`, `district`, `agencyName` and `phoneNumbers`.
- The example run returned ten rows, and every field that was empty on some row is named below.

---

## Prerequisites and setup

You need three things:

1. **Python 3**, with `pip`.
2. A free **Apify account**. You can sign up with an email address or a GitHub login.
3. Your **Apify API token**. The script reads it from the `APIFY_API_TOKEN` environment variable, so it never sits in the code.

Install the Apify API client for Python and export the token:

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

The `-U` flag matters: a plain install without it keeps an older 2.x client if one is already installed, and this guide's code expects the 3.x API, where `call()` returns a typed run object.

No scraping code is needed on your side. The Actor reads the public pages, and the proxy is handled for you.

---

## Understanding Immowelt Scraper

The Actor reads [immowelt.de](http://immowelt.de)'s public search results for one place and one kind of property at a time. It needs no browser and no login. Its rows carry the fields the site publishes in those results.

It is not affiliated with immowelt. Its job is to turn those search results into rows you can filter and sort in code.

The Actor's main limits are the site's own. A search returns at most 9,990 results, and the run logs a warning when a search is bigger. Auction listings are left out of a buy search unless you turn `includeAuctions` on.

Each row also keeps the agency's profile link and website, and the contact name the listing shows. A rent row carries the cold rent, and the warm rent when the listing shows one. A search that matches nothing ends as SUCCEEDED with a status message, and a run that cannot read its location ends as FAILED with the reason.

---

## Step-by-step walkthrough

### Step 1: Open the Actor page

Open the [Immowelt Scraper page on the Apify Store](https://apify.com/reventadata/immowelt-scraper) to read its description and the input form. This guide calls the Actor from the API, so the only name you need in code is `reventadata/immowelt-scraper`.

### Step 2: Choose the search

The Actor takes these input fields. A value outside the list for `transaction`, `propertyType` or `sortBy` is refused before the run starts.

- `transaction`: `buy` or `rent`.
- `propertyType`: `apartment` or `house`.
- `location`: a city name as [immowelt.de](http://immowelt.de) writes it, such as `Berlin`, `München` or `Frankfurt am Main`, `Deutschland` for the whole country, or a place id such as `AD08DE8634`. A name the site does not know stops the run with an error.
- `maxPrice`: optional, in EUR. On a rent search it limits the monthly rent. It is left out of the request when empty.
- `sortBy`: `relevance` (the site's own order) or `priceAsc` (cheapest first).
- `includeAuctions`: buy searches only, off by default. When on, auction and compulsory-auction listings are included.
- `maxItems`: the cap on rows, 1000 by default.
- `maxPages`: the cap on result pages. A page holds 30 listings for apartments and 40 for houses.

This guide's run uses `transaction` `buy`, `propertyType` `apartment`, `location` `berlin`, `maxItems` 10 and `maxPages` 1. That is one page of results, cut to ten rows:

```json
{
    "transaction": "buy",
    "propertyType": "apartment",
    "location": "berlin",
    "maxItems": 10,
    "maxPages": 1
}
```

### Step 3: Run it from Python

The script below starts the Actor with that input, waits for the run to finish, reads the default dataset and prints two lines per listing. Each run is checked before its rows are read.

```python
import os
from apify_client import ApifyClient

# 1. Initialise the client with your token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Describe the search: apartments to buy in Berlin, one page, 10 rows
run_input = {
    "transaction": "buy",
    "propertyType": "apartment",
    "location": "berlin",
    "maxItems": 10,
    "maxPages": 1,
}

# 3. Start the Actor and wait for it to finish
run = client.actor("reventadata/immowelt-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}).")

# 4. Read the rows from the run's default dataset
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} listings.\n")

# 5. Print two lines per listing
for item in items:
    print(f"{item['price']} EUR, {item['areaM2']} m2, {item['rooms']} rooms, {item['district']}")
    print(f"  {item['agencyName']} | {item['url']}")
```

Run with the input above, it prints two lines per listing.

One complete row from the run, the first listing, with `imageUrls` cut to its first entry and the `searchUrl` field left out:

```json
{
    "id": "256Q14GY2JL7",
    "legacyId": "1215b46c-9e03-4081-bc72-67209544ff9f",
    "url": "https://www.immowelt.de/expose/1215b46c-9e03-4081-bc72-67209544ff9f",
    "title": "Wohnung zum Kauf",
    "headline": "Sehr gepflegte 2-Zimmer-Wohnung mit ansprechenden Wohnraum und nützlichem Kellerraum",
    "descriptionSnippet": "Diese charmante und gepflegte Etagenwohnung bietet eine ideale Gelegenheit für Immobilieninvestoren oder Eigennutzer. Mit einer Wohnfläche von 45 m² präsentiert sich diese Immobilie in einem hervorra...",
    "transaction": "buy",
    "propertyType": "APARTMENT",
    "propertySubType": null,
    "price": 170000,
    "currency": "EUR",
    "priceOnRequest": false,
    "pricePerSquareMeter": 3778,
    "coldRent": null,
    "warmRent": null,
    "areaM2": 45,
    "plotAreaM2": null,
    "rooms": 2,
    "bedrooms": null,
    "floor": "3 Geschosse",
    "availableFrom": "frei ab 01.02.2027",
    "energyClass": "D",
    "street": "Wendenschloßstraße",
    "zipCode": "12557",
    "city": "Berlin",
    "district": "Köpenick",
    "addressPublished": true,
    "listedAt": "2025-12-01T09:01:14.95Z",
    "updatedAt": "2026-11-17T12:27:32.784Z",
    "hasBrokerageFee": false,
    "isNew": true,
    "hasFloorPlan": false,
    "hasVirtualTour": false,
    "hasVideo": false,
    "imageUrl": "https://mms.immowelt.de/3/2/9/9/329954f0-f004-47bc-ba98-2b821cb41256.jpg",
    "imageUrls": [
        "https://mms.immowelt.de/3/2/9/9/329954f0-f004-47bc-ba98-2b821cb41256.jpg"
    ],
    "sellerType": "PROFESSIONAL",
    "publisherType": "AGENCY",
    "agencyName": "Immobilien Konzept",
    "agencyProfileUrl": "https://www.immowelt.de/profil/02d166243f7d43cc95210d5429f9cadd",
    "agencyWebsite": "http://www.immobilienkonzept-amberg.de/",
    "agencyAddress": "Schrannenplatz 6, 92224 Amberg",
    "contactName": "Herr Andreas Kiener",
    "phoneNumbers": [
        "09621 1770799",
        "0173 3976 814"
    ]
}
```

### Step 4: Read the rows

Each row is one listing, so a sorted view is one line of code away. The script above prints the price, the area, the rooms, the district, the agency and the listing link.

### Step 5: Check the run

If you want the run's status message or its log, read `run.status` first, as the script does. A run that returns no rows still ends as SUCCEEDED when the search matched nothing, and the status message says so. A run that ends FAILED names the reason in its log.

---

## Working with the API

The script uses three calls from the official client: `call()` starts the Actor and waits for the run, `run.status` tells you how it ended, and `run.default_dataset_id` points to the rows. `list_items()` returns the rows as a list of dictionaries, which is what the loop reads.

Error handling in the script is one check: a run that did not end as SUCCEEDED stops the script with a message that includes the status. A run that returns some rows and then stops early keeps the rows it already wrote, and its log says so.

The client reads the run's status with `run.status`, and the rows from the dataset id in `run.default_dataset_id`. Each run has its own dataset, so a second call never mixes its rows with the first.

If you want the rows as a file, write `items` to a JSON file with the standard library. The script above prints them instead, so the file step is yours to add.

To repeat a search, change the input dictionary and call the Actor again. The input fields are the same ones listed in Step 2, so there is nothing else to configure. Keep the token in the environment, as the script does, and never print it.

---

## Advanced usage patterns

**Several searches in one script.** Call the Actor once per search and merge the lists. Within one run, a listing that appears twice is kept once. Across runs, the script must deduplicate by the `id` field itself, because the Actor does not compare rows between runs.

**Narrowing a large search.** A search with more than 9,990 results returns the first 9,990 and logs a warning. Split it into smaller searches: a different city or district as `location`, or several `maxPrice` bands, one run per band.

**Cheapest first for monitoring.** `sortBy` set to `priceAsc` puts the lowest prices first. Pair it with a small `maxItems` to look at the most affordable listings without reading a whole search.

**Tracking new listings.** Keep the `id` values from one run and compare them with the next run's `id` values. A listing whose `id` the earlier run did not return is new to your list. This guide does not test that comparison on a schedule.

**Passing the rows on.** The rows are plain JSON, so any tool that reads JSON can take them next. This guide does not test a schedule, a webhook or an integration, and it makes no claim about how those behave.

---

## Understanding your data

Each row has 45 fields. The ones that change most between listings are these, and `id` is the value the Actor uses to skip a repeated listing within one run:

- `price` and `pricePerSquareMeter`: the asking price in EUR and the price per square metre the listing states. On rentals, `price` is the cold rent.
- `areaM2`, `rooms`, `bedrooms`, `floor`: size, room count, bedrooms and floor as published.
- `district`, `city`, `zipCode`, and `street`: the location. `street` is filled only when `addressPublished` is true.
- `agencyName`, `agencyProfileUrl`, `agencyWebsite`, `phoneNumbers`: the agency and the phone numbers it published.
- `isNew`, `hasFloorPlan`, `hasVirtualTour`, `hasVideo`, `hasBrokerageFee`: the listing's own tags, true or false.
- `legacyId` and `url`: the listing's own identifiers and its link.

The sample run's ten rows show a price range from 136000 to 4450000 EUR, areas from 45 to 371.09 square metres, and 6 of the 10 rows tagged as new. Four fields are empty on every row of this run: `propertySubType`, `coldRent`, `warmRent` and `plotAreaM2`. `street` is empty on 2 rows, both with `addressPublished` set to false. `bedrooms` is empty on 2 rows, `availableFrom` on 5 and `energyClass` on 1.

---

## Troubleshooting guide

**Zero rows, status SUCCEEDED.** The search matched nothing. The status message says so. Try a broader search: drop `maxPrice`, or switch `propertyType`.

**Zero rows, status FAILED.** Either the `location` is a name the site does not know, or the pages could not be read. The run ends with the reason in its log. For a location error, check the spelling against [immowelt.de](http://immowelt.de)'s own search, or use a place id.

**Fewer rows than expected.** The run log ends with `Skipped N: reason` lines and `Pushed N row(s).`. A listed entry without data in the page is counted as skipped. Read the log lines before you change the input.

**Missing photos or contacts.** In this run every row carried at least one photo and one phone number. A field the listing does not carry is `null` or an empty list, not a missing key.

**The price is null.** The listing has no price, and `priceOnRequest` is true. The Actor writes `null`, never `0`.

---

## Best practices

- Keep test runs small. Set `maxItems` and `maxPages` while you build the script, then raise them.
- Keep the token in an environment variable, and never paste it into a shared script or a post.
- Compare listings by `id`, not by title. The title repeats across listings: in this run seven of the ten titles are exactly `Wohnung zum Kauf`.
- Read the status before you read the rows, as the script does.
- Save the raw rows of each run, so a later change to your script can be checked against them.
- Check that your use of the data complies with immowelt's terms and with data-protection law. The Actor is not affiliated with immowelt.

---

## Conclusion and next steps

You now have a script that starts Immowelt Scraper, waits for the run, checks its status, reads the rows and prints a summary for each listing. The same script takes any input from Step 2, so changing a city, switching to rentals or raising `maxItems` needs no new code.

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

Try Immowelt Scraper yourself and let me know what you build!

*About the author: reventadata builds and publishes data extraction Actors on the Apify Store.*
