# Immowelt Search Results Scraper (`automation-lab/immowelt-search-results-scraper`) Actor

🏠 Extract normalized German sale and rental listing cards from public Immowelt search URLs for property monitoring, market research, price analysis, and lead workflows.

- **URL**: https://apify.com/automation-lab/immowelt-search-results-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Search Results Scraper

Collect clean German property inventory from public Immowelt search URLs—without opening protected detail pages or maintaining your own scraper.

Paste a sale or rental search URL and get normalized listing cards with prices, rooms, floor area, addresses, contacts, image counts, badges, energy classes, and source metadata. Export the results as JSON, CSV, Excel, XML, RSS, or through the Apify API.

- 🏠 **Search URL in, structured listings out**
- 🇩🇪 **German prices and decimal commas normalized**
- 🔁 **Duplicate listing IDs removed across searches**
- 📊 **Ready for property monitoring and market analysis**
- 🔌 **Works with schedules, webhooks, API clients, and MCP**

> This version is deliberately search-results-only. It reads public listing cards and does not request Immowelt detail pages.

### What does Immowelt Search Results Scraper do?

The Actor downloads the server-rendered results behind public `immowelt.de/suche/` URLs and converts each property card into one flat dataset row.

It can extract:

- listing UUID or project ID and canonical listing URL;
- asking price, EUR currency, and visible price per square metre;
- property type and sale, rental, or auction intent;
- room count, floor area, floor, and visible availability;
- address, street, locality, and German postcode;
- contact and agency names shown on the card;
- preview image URL, image count, badges, and energy class;
- summary, original search URL, result position, and scrape timestamp.

The Actor deduplicates listings by ID when the same property appears in more than one supplied search.

### Who is it for?

#### Property investors

Track asking prices, price per m², room counts, and inventory for focused acquisition areas.

#### Brokers and agencies

Build repeatable market-coverage exports, identify visible contacts, and compare active stock across filtered searches.

#### Real-estate analysts

Create timestamped snapshots for neighborhood coverage, pricing distributions, and listing-change research.

#### Proptech teams

Feed normalized German listing cards into internal databases, dashboards, alerts, and enrichment pipelines.

#### Researchers and journalists

Collect reproducible public search-result evidence without manually copying cards from the website.

### Why use this Immowelt scraper?

Building and maintaining a property scraper means handling URL validation, German number formats, selector changes, duplicate records, retries, datasets, and API deployment.

This Actor provides those operational pieces in one run:

- ✅ strict validation for public Immowelt search URLs;
- ✅ HTTP-first extraction with low compute requirements;
- ✅ fail-closed behavior when no listing cards can be extracted;
- ✅ optional Apify Proxy support for challenged traffic;
- ✅ typed, flat fields that work well in CSV and spreadsheets;
- ✅ predictable pay-per-result billing;
- ✅ Apify scheduling, API, webhook, and storage integrations.

### What Immowelt data can I extract?

| Field | Description | Example |
|---|---|---|
| `listingId` | Listing UUID or project ID | `1215b46c-9e03-4081-bc72-67209544ff9f` |
| `listingUrl` | Canonical public listing URL | `https://www.immowelt.de/expose/...` |
| `price` | Normalized numeric asking price | `170000` |
| `priceCurrency` | Currency shown on the card | `EUR` |
| `pricePerSquareMeter` | Visible numeric €/m² | `3778` |
| `propertyType` | Apartment, studio, house, or another visible type | `Wohnung` |
| `intent` | `buy`, `rent`, `auction`, or `unknown` | `buy` |
| `rooms` | Normalized room count | `2` |
| `floorAreaSquareMeters` | Normalized area | `45` |
| `floor` | Visible floor text | `EG` |
| `availability` | Visible availability text, when present | `frei ab sofort` |
| `address` | Complete card address | `Köpenick, Berlin (12557)` |
| `streetAddress` | Street portion, when displayed | `Stargarder Straße 74` |
| `locality` | Locality/city portion | `Prenzlauer Berg, Berlin` |
| `postcode` | German postcode | `10437` |
| `contactName` | Visible contact name | `Herr Andreas Kiener` |
| `agencyName` | Visible agency name | `Immobilien Konzept` |
| `imageCount` | Images advertised by the gallery | `14` |
| `imageUrl` | First search-card image | `https://mms.immowelt.de/...jpg` |
| `badges` | Visible card tags | `["NEU"]` |
| `energyClass` | Visible energy class | `D` |
| `summary` | Search-card description excerpt | `Diese charmante ...` |
| `sourceSearchUrl` | Search that produced the row | `https://www.immowelt.de/suche/...` |
| `position` | One-based position on that result page | `1` |
| `scrapedAt` | UTC extraction timestamp | `2026-07-20T03:00:00.000Z` |

Optional fields are omitted when Immowelt does not show them on a card.

### How much does it cost to scrape Immowelt listings?

The Actor uses pay per event:

- a small **$0.005 start fee** per run;
- a tiered fee per saved listing, anchored at **$0.000077577 per result on BRONZE**.

At the BRONZE rate:

- 10 listings cost about **$0.00578** including the start fee;
- 100 listings cost about **$0.01276** including the start fee;
- 1,000 listings cost about **$0.08258** including the start fee.

Apify plan tiers may receive lower result prices. Open the Actor pricing tab for the authoritative live amount. Compute and proxy usage are covered by pay-per-event billing where the platform pricing specifies it.

### How to scrape Immowelt search results

1. Open Immowelt and configure a public property search.
2. Copy the resulting URL under `https://www.immowelt.de/suche/`.
3. Open this Actor and paste the URL into **Immowelt search URLs**.
4. Choose a small **Maximum listings** value for the first run.
5. Click **Start**.
6. Review the dataset table.
7. Export JSON, CSV, Excel, XML, or connect the run to your workflow.

For wider coverage, provide several narrower search URLs—for example separate property types, districts, price bands, or sale/rental searches.

### Input parameters

#### `startUrls`

Required array of one to ten public Immowelt search-result URLs. The Actor accepts only HTTPS URLs on `immowelt.de` whose path starts with `/suche/`.

Detail URLs under `/expose/`, home pages, and third-party URLs are rejected.

#### `maxItems`

Maximum unique records saved across all searches. Range: 1–300. Default: 20. The prefilled example uses 10 to keep a first run fast and inexpensive.

#### `proxyConfiguration`

Optional Apify Proxy configuration. Leave it empty while anonymous direct access works. If your run is challenged, try a German datacenter or residential proxy according to your Apify plan and compliance needs.

#### `debugMode`

When enabled, successful response HTML is saved to the run key-value store. Use it only for troubleshooting because raw HTML consumes storage and can change frequently.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634"
    }
  ],
  "maxItems": 10,
  "debugMode": false
}
````

A multi-market monitoring run can use several URLs:

```json
{
  "startUrls": [
    { "url": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634" },
    { "url": "https://www.immowelt.de/suche/mieten/wohnung/hamburg/hamburg-20095/ad08de1031" }
  ],
  "maxItems": 50
}
```

Always copy current URLs from Immowelt; locations and path identifiers may change.

### Example output

```json
{
  "listingId": "1215b46c-9e03-4081-bc72-67209544ff9f",
  "listingUrl": "https://www.immowelt.de/expose/1215b46c-9e03-4081-bc72-67209544ff9f",
  "contactName": "Herr Andreas Kiener",
  "agencyName": "Immobilien Konzept",
  "imageCount": 14,
  "price": 170000,
  "priceCurrency": "EUR",
  "pricePerSquareMeter": 3778,
  "propertyType": "Wohnung",
  "intent": "buy",
  "rooms": 2,
  "floorAreaSquareMeters": 45,
  "address": "Köpenick, Berlin (12557)",
  "locality": "Köpenick, Berlin",
  "postcode": "12557",
  "badges": [],
  "energyClass": "D",
  "sourceSearchUrl": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634",
  "position": 1,
  "scrapedAt": "2026-07-20T03:00:00.000Z"
}
```

The live values change with Immowelt inventory. The example illustrates types and field names, not a guaranteed active listing.

### Data quality and normalization

German values such as `316.000 €`, `5.576 €/m²`, and `56,7 m²` become JSON numbers `316000`, `5576`, and `56.7`.

The Actor:

- trims non-breaking spaces and repeated whitespace;
- derives IDs from canonical listing URLs;
- converts relative and protocol-relative links to absolute HTTPS URLs;
- splits visible postcodes and locality components conservatively;
- omits missing optional values instead of inventing data;
- deduplicates by listing ID across all supplied searches;
- records source URL and page position for traceability.

### Coverage and pagination

Immowelt currently server-renders the first result page, normally up to 30 cards, for each supplied search URL. This version extracts that public page.

Automated deep pagination is not advertised because the browser pagination backend can challenge automated requests. To collect broader, controlled coverage, supply multiple narrower filtered URLs. Examples include:

- separate Berlin districts;
- separate apartment and house searches;
- separate sale and rental searches;
- non-overlapping price bands;
- separate room-count ranges.

This approach is transparent and avoids silently returning repeated page-one data.

### Tips for reliable Immowelt monitoring

- 🎯 Use narrow, stable search URLs rather than one country-wide search.
- 🧪 Start with 5–10 listings before increasing a scheduled workflow.
- 🔑 Use `listingId` as your database primary key.
- 🕐 Compare `scrapedAt` snapshots to detect new or removed inventory.
- 📍 Group by `postcode` or `locality` for local market analysis.
- 💶 Calculate your own price statistics from numeric `price` and `floorAreaSquareMeters`.
- 🧹 Expect optional fields: private listings and agencies show different card content.
- 🔄 Schedule at a responsible cadence; avoid unnecessary repeated runs.

### Scheduling and change monitoring

Create an Apify schedule to run the same input daily or hourly. Send the completed dataset to a webhook, Make, Zapier, Google Sheets, or your database.

A common monitoring design is:

1. run the Actor on a fixed set of search URLs;
2. store rows keyed by `listingId`;
3. compare current and previous IDs;
4. alert on new IDs, missing IDs, or changed prices;
5. retain `sourceSearchUrl` and `scrapedAt` as evidence.

The Actor outputs snapshots; your downstream system decides what counts as a change.

### Integrations

#### Google Sheets market watch

Export CSV or use Make to append listing ID, postcode, rooms, area, and price to a sheet. Add formulas for €/m² or price-band summaries.

#### Database inventory pipeline

Use a webhook after each run. Upsert records by `listingId`, retain the latest `scrapedAt`, and store historical price observations in a separate table.

#### Slack or email alerts

Filter results downstream for new listings below a target price per m², then send the listing URL and normalized facts to a channel.

#### BI dashboards

Load the dataset into BigQuery, Snowflake, PostgreSQL, or a data warehouse. Build charts by postcode, property type, intent, and scrape date.

#### AI research workflows

Use MCP to ask an assistant to run a focused search export, summarize visible inventory, or identify records matching numeric constraints.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/immowelt-search-results-scraper').call({
  startUrls: [{
    url: 'https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634'
  }],
  maxItems: 10
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/immowelt-search-results-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634'
    }],
    'maxItems': 10,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~immowelt-search-results-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{
      "url": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634"
    }],
    "maxItems": 10
  }'
```

Poll the returned run ID or use the synchronous Apify endpoint when your client can wait for completion.

### Use Immowelt Search Results Scraper with MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/immowelt-search-results-scraper"
```

For Claude Desktop, Cursor, or VS Code, use an HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/immowelt-search-results-scraper"
    }
  }
}
```

Example prompts:

- “Run the Immowelt scraper for this Berlin sale search and return 10 listings.”
- “Collect these three Immowelt district searches and rank listings by price per m².”
- “Export current rental cards for my supplied Hamburg search URL and summarize room counts.”
- “Compare listing IDs in today’s dataset with the previous snapshot.”

MCP runs the Actor with the same validated input contract as the Console and API.

### Legality and responsible use

Immowelt search cards are publicly visible, but public availability does not remove your responsibilities.

You should:

- review Immowelt’s current terms and robots guidance;
- collect only data needed for a legitimate purpose;
- use responsible limits and scheduling frequency;
- avoid republishing personal contact data without a lawful basis;
- follow GDPR and other privacy requirements applicable to your location and use case;
- secure exports and delete records when they are no longer needed;
- respect intellectual-property and database rights.

This tool does not provide legal advice. You are responsible for deciding whether your specific collection and use are lawful.

### Limitations

- V1 extracts public search-result cards only.
- It does not request `/expose/` detail pages.
- Each URL contributes the first server-rendered page, normally up to 30 cards.
- Immowelt can change selectors, card fields, access controls, and URLs.
- Some cards omit streets, contacts, agencies, images, price per m², energy class, floor, or availability.
- Sponsored, project, or suggestion cards may differ from ordinary listings.
- The Actor does not infer hidden fields, coordinates, phone numbers, amenities, deposits, or full image galleries.
- An empty search or challenged response fails closed rather than producing a successful empty dataset.

### Troubleshooting

#### Why did the run reject my URL?

Use the URL shown after configuring a public Immowelt search. It must use HTTPS, the `immowelt.de` host, and a path beginning with `/suche/`. Listing detail URLs are intentionally unsupported.

#### Why did the run say no listing cards were found?

First open the same URL anonymously and confirm it still shows results. If it does, retry with an appropriate German Apify Proxy configuration. If it does not, create a fresh search URL.

#### Why did I get fewer records than `maxItems`?

`maxItems` is a ceiling, not a promise. A single server-rendered result page normally contains up to 30 cards, and duplicates across supplied URLs are saved only once.

#### Why is a field missing?

Immowelt cards vary. The Actor omits optional fields that are not visible instead of guessing. Use search-card fields only; detail-only values are outside v1.

### FAQ

#### Can it scrape both sale and rental listings?

Yes. Supply the public Immowelt URL for the sale or rental search. The `intent` field is normalized from visible card text.

#### Can it scrape houses, apartments, land, and commercial properties?

It processes listing cards returned by valid public search URLs. Field availability depends on the selected property type and card layout.

#### Does it require an Immowelt account?

No. The product uses anonymous public search-result HTML.

#### Does it scrape contact phone numbers or full descriptions?

No. It emits only contact names and summary text visible on search cards. It does not open protected detail pages.

#### How are duplicates handled?

Rows are deduplicated by the UUID or project identifier in the listing URL across the complete run.

#### Can I schedule the Actor?

Yes. Use Apify schedules and webhooks with a fixed set of current search URLs.

#### Can I export to Excel?

Yes. Apify datasets support Excel, CSV, JSON, XML, RSS, and API access.

#### Is it an official Immowelt API?

No. It is an independent scraper for publicly visible search-result cards and is not affiliated with Immowelt.

### Related real-estate scrapers

Need another property market? Explore these automation-lab Actors:

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) for US property listings.
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper) for US real-estate search data.
- [Rightmove Scraper](https://apify.com/automation-lab/rightmove-scraper) for UK property listings.
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper) for US housing search workflows.
- [PropertyFinder Scraper](https://apify.com/automation-lab/propertyfinder-scraper) for Property Finder markets.
- [RE/MAX Portugal Scraper](https://apify.com/automation-lab/remax-portugal-scraper) for Portuguese property listings.

Choose the Actor for the actual source domain you need; schemas and source coverage differ.

### Support

If a valid public Immowelt search URL stops producing cards, include:

- the search URL;
- the Apify run ID;
- whether a proxy was configured;
- the approximate time of the run;
- a short description of the expected visible listings.

Do not post private credentials or unnecessary personal data. The run log and optional debug HTML help diagnose selector or access changes.

# Actor input Schema

## `startUrls` (type: `array`):

Public URLs under https://www.immowelt.de/suche/. Search filters in each URL are preserved.

## `maxItems` (type: `integer`):

Stop after saving this many unique listing cards across all supplied searches.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Leave empty while direct anonymous access works; use a German proxy if Immowelt challenges your traffic.

## `debugMode` (type: `boolean`):

Store successful search HTML in the run key-value store for selector diagnostics.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634"
    }
  ],
  "maxItems": 10,
  "debugMode": false
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634"
        }
    ],
    "maxItems": 10,
    "debugMode": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/immowelt-search-results-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 = {
    "startUrls": [{ "url": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634" }],
    "maxItems": 10,
    "debugMode": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/immowelt-search-results-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 '{
  "startUrls": [
    {
      "url": "https://www.immowelt.de/suche/kaufen/wohnung/berlin/berlin-10115/ad08de8634"
    }
  ],
  "maxItems": 10,
  "debugMode": false
}' |
apify call automation-lab/immowelt-search-results-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Immowelt Search Results Scraper",
        "description": "🏠 Extract normalized German sale and rental listing cards from public Immowelt search URLs for property monitoring, market research, price analysis, and lead workflows.",
        "version": "0.1",
        "x-build-id": "87qvk6TtwWKiMAdNq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~immowelt-search-results-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-immowelt-search-results-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/automation-lab~immowelt-search-results-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-immowelt-search-results-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/automation-lab~immowelt-search-results-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-immowelt-search-results-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Immowelt search URLs",
                        "type": "array",
                        "description": "Public URLs under https://www.immowelt.de/suche/. Search filters in each URL are preserved.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Stop after saving this many unique listing cards across all supplied searches.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave empty while direct anonymous access works; use a German proxy if Immowelt challenges your traffic."
                    },
                    "debugMode": {
                        "title": "Save response HTML",
                        "type": "boolean",
                        "description": "Store successful search HTML in the run key-value store for selector diagnostics.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```