# Immowelt DE $0.8💰 Powerful Filters + Deep Search (`abotapi/immowelt-de-scraper`) Actor

Extract property listings from immowelt.de. Get fully-detailed listings including price, GPS coordinates, rooms, area, images, energy class, agent contacts, and more.

- **URL**: https://apify.com/abotapi/immowelt-de-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Real estate, Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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

## Immowelt Scraper

Extract property listings from [immowelt.de](https://www.immowelt.de), one of Germany's top real estate portals. Get fully-detailed listings including price, GPS coordinates, rooms, area, images, energy class, agent contacts, and more.

### Why This Scraper?

* **40+ fields per listing.** Price, address, coordinates, rooms, living area, floor, construction year, energy class, image gallery, agent name, company, phone, website, tags, dates, and more.
* **GPS coordinates.** Latitude and longitude added to every listing automatically, no extra configuration.
* **Two input modes.** Pick a state and city from dropdowns, or paste any Immowelt search URL you already refined in your browser.
* **Rich filter set.** Price, rooms, living area, construction year, sort order, all passed straight to Immowelt so the results are exactly what the site would show.
* **Auto pagination.** Walks every result page forward to the limit you set. 30 listings per page.
* **Cheap.** Small bandwidth footprint per listing and no expensive browser rendering.
* **Both Buy and Rent.** Apartments, houses, plots, and offices.

### Data You Get

| Field | Example |
|---|---|
| Title | `Wohnung zum Kauf` |
| Price | `545.000 €` (numeric and formatted) |
| Price per m² | `7.370 €/m²` |
| Rooms | `3` |
| Living area | `85.5 m²` |
| Plot area (houses) | `270 m²` |
| Floor | `4. Geschoss` |
| Energy class | `C` |
| Address | Country, city, district, postcode, street |
| Coordinates | `48.1546, 11.5597` |
| Agent | Name, company, phone, website, profile URL, rating |
| Images | Up to 40+ image URLs per listing, annotated with room type |
| Tags | `isNew`, `has3DTour`, `hasBrokerageFee`, `isExclusive` |
| Origin | `strict`, `enlarged`, or `suggested` (so you can filter fallback results) |
| Dates | Creation, update |

### How to Use

#### Search by Location

Pick a German state from the dropdown, type any city name. Works for any town in the selected state.

```json
{
  "mode": "filter",
  "locations": [
    { "state": "berlin", "city": "Berlin" }
  ],
  "listingType": "Buy",
  "propertyType": "Apartment",
  "maxPages": 10
}
````

#### Search with Filters

```json
{
  "mode": "filter",
  "locations": [{ "state": "bayern", "city": "München" }],
  "listingType": "Buy",
  "propertyType": "Apartment",
  "priceMin": 400000,
  "priceMax": 800000,
  "roomsMin": 2,
  "roomsMax": 3,
  "livingSpaceMin": 50,
  "livingSpaceMax": 100,
  "sortBy": "PriceAsc",
  "maxPages": 10
}
```

#### Multiple Cities

```json
{
  "mode": "filter",
  "locations": [
    { "state": "berlin", "city": "Berlin" },
    { "state": "bayern", "city": "München" },
    { "state": "hamburg", "city": "Hamburg" },
    { "state": "nordrhein-westfalen", "city": "Köln" },
    { "state": "hessen", "city": "Frankfurt am Main" }
  ],
  "listingType": "Rent",
  "propertyType": "Apartment",
  "maxPages": 20
}
```

#### Direct URLs with auto pagination

Refine a search in your browser, copy the URL, paste it here. If the URL contains `page=N`, scraping starts from page N and walks forward.

```json
{
  "mode": "url",
  "urls": [
    "https://www.immowelt.de/classified-search?distributionTypes=Rent&estateTypes=Apartment&locations=AD08DE1113&numberOfRoomsMin=2&spaceMin=60"
  ],
  "maxPages": 20
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `filter` | `filter` for state plus city inputs, or `url` for direct URLs |
| `locations` | array | Berlin | State plus city pairs (Filter mode only) |
| `urls` | string\[] | example URL | Immowelt search URLs (URL mode only); honors `page=N` as start page |
| `listingType` | string | `Buy` | `Buy` or `Rent` (Filter mode only) |
| `propertyType` | string | `Apartment` | `Apartment`, `House`, `Plot`, or `Office` (Filter mode only) |
| `priceMin` / `priceMax` | number | no limit | Price range in EUR (Filter mode only) |
| `roomsMin` / `roomsMax` | number | no limit | Number of rooms (Filter mode only) |
| `livingSpaceMin` / `livingSpaceMax` | number | no limit | Living area in m² (Filter mode only) |
| `constructionYearMin` / `constructionYearMax` | number | no limit | Construction year range (Filter mode only) |
| `sortBy` | string | `Default` | `Default`, `MostRecent`, `PriceAsc`, `PriceDesc` (Filter mode only) |
| `maxPages` | number | `5` | Max pages per search, 30 listings per page |
| `maxListings` | number | unlimited | Hard cap across the whole run |
| `includeCoordinates` | boolean | `true` | Add latitude and longitude to each listing |
| `fetchDetails` | boolean | `false` | Visit each listing's expose page for the long description (roughly 10× more bandwidth) |
| `proxy` | object | Apify RES + DE | Proxy config, German residential recommended |

### Output Example

```json
{
  "id": "<listing-id>",
  "url": "<expose-url>",
  "listingType": "Buy",
  "origin": "strict",
  "propertyType": "APARTMENT",
  "title": "<listing-title>",
  "priceValue": 450000,
  "priceCurrency": "EUR",
  "priceDisplay": "450.000 €",
  "pricePerSqm": "5.625 €/m²",
  "rooms": 3,
  "livingSpace": 80.0,
  "plotArea": null,
  "floor": "2.",
  "energyClass": "C",
  "country": "DEU",
  "city": "<city>",
  "district": "<district>",
  "postcode": "<zip>",
  "street": "<street>",
  "latitude": 52.5200,
  "longitude": 13.4050,
  "agentName": "<agent name>",
  "agentCompany": "<agency name>",
  "agentType": "AGENCY",
  "agentPhones": ["<phone>"],
  "agentWebsite": "<agency website>",
  "agentProfileUrl": "<agent profile>",
  "agentRating": 4.8,
  "agentReviews": 12,
  "imageCount": 20,
  "images": ["<image-url-1>", "<image-url-2>"],
  "hasFloorplan": true,
  "has3DTour": false,
  "hasBrokerageFee": false,
  "isExclusive": false,
  "isNew": true,
  "creationDate": "2026-04-01T12:00:00.000Z",
  "updateDate": "2026-04-15T08:30:00.000Z",
  "scrapedAt": "2026-04-21T10:00:00.000Z"
}
```

### Performance

Measured on a 10 page Munich scrape (300 listing target):

| Metric | Value |
|---|---|
| Wall time | under 1 minute |
| Cost per 1,000 listings | under $1 |

### Plan requirement

This actor needs a German residential proxy to return full data. You have two options:

- **Paid Apify plan** (Starter and above). Keep the default proxy setting. Apify's RESIDENTIAL pool with country DE is included in paid plans and works out of the box.
- **Bring your own proxy** (any plan, including Free). In the proxy field, uncheck "Use Apify proxy" and paste your own residential proxy URLs (Bright Data, Oxylabs, SmartProxy, IPRoyal, etc.). The actor rotates through them on retries.

The Apify Free plan does not include residential proxy access. If you run the actor on Free without setting custom proxy URLs, it will stop early with a clear message pointing you at these two options.

### Tips

- A German residential proxy gives the best results. The built-in Apify Residential with country DE works out of the box on paid plans.
- `includeCoordinates` is free performance-wise, leave it on.
- Leave `fetchDetails` off unless you need the long description field. The search pages already include price, address, agent, images, energy class, and most of the useful fields.
- For large scrapes, split the work into smaller URL mode runs using `page=N` so each run starts where the last one finished.
- `origin` on each record tells you whether it is a strict filter match, an enlarged radius match, or a nearby suggestion. Handy when Immowelt's search returns a mix for narrow filters.

### About

Built and maintained for reliable, cost-effective scraping of Immowelt. Report any issues or ideas in the Apify Store listing.

# Actor input Schema

## `mode` (type: `string`):

Filter mode = pick state + city from dropdowns. URL mode = paste any immowelt.de search URL with your filters already applied (great for re-using a search you already refined in a browser).

## `locations` (type: `array`):

Pick a German federal state, then enter the city name. Any town in the state works (we resolve it automatically). Add multiple entries to scrape several cities in one run.

## `listingType` (type: `string`):

Pick Buy (Kauf) or Rent (Miete). Filter mode only.

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

What kind of property to search for. Filter mode only.

## `priceMin` (type: `integer`):

Minimum price in euros. Filter mode only. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Maximum price in euros. Filter mode only. Leave empty for no maximum.

## `roomsMin` (type: `integer`):

Minimum number of rooms. Filter mode only.

## `roomsMax` (type: `integer`):

Maximum number of rooms. Filter mode only.

## `livingSpaceMin` (type: `integer`):

Minimum living area in square meters. Filter mode only.

## `livingSpaceMax` (type: `integer`):

Maximum living area in square meters. Filter mode only.

## `constructionYearMin` (type: `integer`):

Earliest construction year. Filter mode only.

## `constructionYearMax` (type: `integer`):

Latest construction year. Filter mode only.

## `sortBy` (type: `string`):

How to order results. Filter mode only — in URL mode the sort is taken from your URL.

## `urls` (type: `array`):

One or more full Immowelt search URLs. Tip: refine a search in your browser, copy the URL, paste it here. If the URL contains page=N, scraping starts at page N and walks forward.

## `maxPages` (type: `integer`):

How many result pages to walk per location / URL. 30 listings per page.

## `maxListings` (type: `integer`):

Hard cap across the whole run. 0 = unlimited (bounded only by Max pages).

## `includeCoordinates` (type: `boolean`):

Enrich each listing with latitude/longitude. Adds ~1 extra request per search page. Fast, no extra cost beyond proxy.

## `fetchDetails` (type: `boolean`):

Fetch the full expose page for each listing — adds the long description and extra attributes, but multiplies your proxy bandwidth by roughly 10×. The search page already includes price, address, agent, images, and energy class, so leave this OFF unless you need the long description.

## `proxy` (type: `object`):

A residential proxy based in Germany gives the cleanest data. The default Apify RESIDENTIAL + country DE works well.

## Actor input object example

```json
{
  "mode": "filter",
  "locations": [
    {
      "state": "berlin",
      "city": "Berlin"
    }
  ],
  "listingType": "Buy",
  "propertyType": "Apartment",
  "sortBy": "Default",
  "urls": [
    "https://www.immowelt.de/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08DE8634"
  ],
  "maxPages": 2,
  "maxListings": 0,
  "includeCoordinates": true,
  "fetchDetails": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "locations": [
        {
            "state": "berlin",
            "city": "Berlin"
        }
    ],
    "urls": [
        "https://www.immowelt.de/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08DE8634"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/immowelt-de-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 = {
    "locations": [{
            "state": "berlin",
            "city": "Berlin",
        }],
    "urls": ["https://www.immowelt.de/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08DE8634"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/immowelt-de-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 '{
  "locations": [
    {
      "state": "berlin",
      "city": "Berlin"
    }
  ],
  "urls": [
    "https://www.immowelt.de/classified-search?distributionTypes=Buy&estateTypes=Apartment&locations=AD08DE8634"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call abotapi/immowelt-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Immowelt DE $0.8💰 Powerful Filters + Deep Search",
        "description": "Extract property listings from immowelt.de. Get fully-detailed listings including price, GPS coordinates, rooms, area, images, energy class, agent contacts, and more.",
        "version": "1.0",
        "x-build-id": "3xg6NPVixzjQ7XJDC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~immowelt-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-immowelt-de-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/abotapi~immowelt-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-immowelt-de-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/abotapi~immowelt-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-immowelt-de-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": {
                    "mode": {
                        "title": "1. Search mode",
                        "enum": [
                            "filter",
                            "url"
                        ],
                        "type": "string",
                        "description": "Filter mode = pick state + city from dropdowns. URL mode = paste any immowelt.de search URL with your filters already applied (great for re-using a search you already refined in a browser).",
                        "default": "filter"
                    },
                    "locations": {
                        "title": "Locations to search (Filter mode)",
                        "type": "array",
                        "description": "Pick a German federal state, then enter the city name. Any town in the state works (we resolve it automatically). Add multiple entries to scrape several cities in one run.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "state": {
                                    "title": "State (Bundesland)",
                                    "type": "string",
                                    "description": "German federal state where the city is located.",
                                    "editor": "select",
                                    "enum": [
                                        "baden-wuerttemberg",
                                        "bayern",
                                        "berlin",
                                        "brandenburg",
                                        "bremen",
                                        "hamburg",
                                        "hessen",
                                        "mecklenburg-vorpommern",
                                        "niedersachsen",
                                        "nordrhein-westfalen",
                                        "rheinland-pfalz",
                                        "saarland",
                                        "sachsen",
                                        "sachsen-anhalt",
                                        "schleswig-holstein",
                                        "thueringen"
                                    ],
                                    "enumTitles": [
                                        "Baden-Württemberg",
                                        "Bayern (Bavaria)",
                                        "Berlin",
                                        "Brandenburg",
                                        "Bremen",
                                        "Hamburg",
                                        "Hessen",
                                        "Mecklenburg-Vorpommern",
                                        "Niedersachsen (Lower Saxony)",
                                        "Nordrhein-Westfalen (NRW)",
                                        "Rheinland-Pfalz",
                                        "Saarland",
                                        "Sachsen (Saxony)",
                                        "Sachsen-Anhalt",
                                        "Schleswig-Holstein",
                                        "Thüringen"
                                    ]
                                },
                                "city": {
                                    "title": "City",
                                    "type": "string",
                                    "description": "City name, e.g. München, Köln, Frankfurt am Main. Any town in the selected state works.",
                                    "editor": "textfield"
                                }
                            },
                            "required": [
                                "state",
                                "city"
                            ]
                        }
                    },
                    "listingType": {
                        "title": "Buy or rent? (Filter mode)",
                        "enum": [
                            "Buy",
                            "Rent"
                        ],
                        "type": "string",
                        "description": "Pick Buy (Kauf) or Rent (Miete). Filter mode only.",
                        "default": "Buy"
                    },
                    "propertyType": {
                        "title": "Property type (Filter mode)",
                        "enum": [
                            "Apartment",
                            "House",
                            "Plot",
                            "Office"
                        ],
                        "type": "string",
                        "description": "What kind of property to search for. Filter mode only.",
                        "default": "Apartment"
                    },
                    "priceMin": {
                        "title": "Min price, € (Filter mode)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in euros. Filter mode only. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Max price, € (Filter mode)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in euros. Filter mode only. Leave empty for no maximum."
                    },
                    "roomsMin": {
                        "title": "Min rooms (Filter mode)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of rooms. Filter mode only."
                    },
                    "roomsMax": {
                        "title": "Max rooms (Filter mode)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of rooms. Filter mode only."
                    },
                    "livingSpaceMin": {
                        "title": "Min living space, m² (Filter mode)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum living area in square meters. Filter mode only."
                    },
                    "livingSpaceMax": {
                        "title": "Max living space, m² (Filter mode)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum living area in square meters. Filter mode only."
                    },
                    "constructionYearMin": {
                        "title": "Built from year (Filter mode)",
                        "minimum": 1800,
                        "type": "integer",
                        "description": "Earliest construction year. Filter mode only."
                    },
                    "constructionYearMax": {
                        "title": "Built until year (Filter mode)",
                        "minimum": 1800,
                        "type": "integer",
                        "description": "Latest construction year. Filter mode only."
                    },
                    "sortBy": {
                        "title": "Sort order (Filter mode)",
                        "enum": [
                            "Default",
                            "MostRecent",
                            "PriceAsc",
                            "PriceDesc"
                        ],
                        "type": "string",
                        "description": "How to order results. Filter mode only — in URL mode the sort is taken from your URL.",
                        "default": "Default"
                    },
                    "urls": {
                        "title": "Search URLs (URL mode)",
                        "type": "array",
                        "description": "One or more full Immowelt search URLs. Tip: refine a search in your browser, copy the URL, paste it here. If the URL contains page=N, scraping starts at page N and walks forward.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many result pages to walk per location / URL. 30 listings per page.",
                        "default": 2
                    },
                    "maxListings": {
                        "title": "Max total listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap across the whole run. 0 = unlimited (bounded only by Max pages).",
                        "default": 0
                    },
                    "includeCoordinates": {
                        "title": "Add GPS coordinates",
                        "type": "boolean",
                        "description": "Enrich each listing with latitude/longitude. Adds ~1 extra request per search page. Fast, no extra cost beyond proxy.",
                        "default": true
                    },
                    "fetchDetails": {
                        "title": "Visit each listing's detail page",
                        "type": "boolean",
                        "description": "Fetch the full expose page for each listing — adds the long description and extra attributes, but multiplies your proxy bandwidth by roughly 10×. The search page already includes price, address, agent, images, and energy class, so leave this OFF unless you need the long description.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "A residential proxy based in Germany gives the cleanest data. The default Apify RESIDENTIAL + country DE works well."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
