# WG-Gesucht Scraper - German Flatshare & Rentals (`logiover/wg-gesucht-scraper`) Actor

WG-Gesucht API alternative: scrape German flatshare & apartment rental listings without login and export to CSV, JSON or Excel. No API key.

- **URL**: https://apify.com/logiover/wg-gesucht-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Real estate, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

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

## WG-Gesucht Scraper - German Flatshare & Rental Data

Export German shared-flat and apartment rental listings from **[WG-Gesucht.de](https://www.wg-gesucht.de)**, Germany's #1 portal for a **WG (Wohngemeinschaft / flatshare) room, a 1-room flat (Wohnung), a whole apartment, a house or a sublet (Zwischenmiete)**. This WG-Gesucht scraper turns any search into a clean dataset across Berlin, Munich, Hamburg, Cologne, Frankfurt, Leipzig and every German city.

No login and no API key are required. Each record carries rent in €, size in m², room count, city, district, street, available-from date, listing type, poster and the listing URL — ready to export to CSV, JSON or Excel for rental-price analysis, flatshare market research or availability tracking. The Actor reads the site's server-rendered listing cards and paginates the whole result set automatically (50+ pages / 1,000+ listings per city).

### What you get

Each WG-Gesucht listing becomes one flat dataset record. Real output fields include:

- **`id`, `title`, `url`** — listing ID, title and canonical listing URL.
- **`listingType`, `propertyType`** — WG room / 1-room / apartment / house / sublet, and the German property type (e.g. `2-Zimmer-Wohnung`).
- **`rent`, `currency`** — rent in EUR.
- **`sizeSqm`, `rooms`** — size in m² and number of rooms.
- **`city`, `district`, `street`** — city, neighbourhood and street.
- **`availableFrom`, `availableTo`** — move-in date, plus move-out date for sublets / Zwischenmiete.
- **`posterName`, `onlineStatus`** — who posted the ad and how recently they were online.
- **`image`** — thumbnail image URL.
- **`sourceUrl`, `scrapedAt`** — the search URL this listing came from and the scrape timestamp.

Output is flat JSON, downloadable as CSV, Excel, JSON or XML, with a ready-made **Listings Overview** dataset view (type, rent, size, rooms, city, district, link).

### Use cases

- **Rental-price analysis** — track rent, €/m² and room counts across Berlin, Munich, Hamburg and more.
- **Flatshare & WG market research** — map WG-room supply, districts and availability over time.
- **Availability & trend monitoring** — schedule daily runs to watch new listings and how fast the market moves.
- **Comps & valuation** — feed rooms, size, district and rent into pricing or affordability models.
- **Portals & dashboards** — power a rental feed or BI dashboard straight from the Apify API.

### How to use

1. Add the Actor to your Apify account and open the input form.
2. On WG-Gesucht, choose a city and category (WG room, 1-room flat, apartment, house), apply your filters, and copy the URL from the address bar.
3. Paste it into **`searchUrls`** — add several URLs to scrape multiple cities and categories in one run. Every filter encoded in the URL is respected and the Actor paginates the whole result set.
4. Set **`maxResults`** (global cap; `0` = no limit) and optionally **`maxResultsPerSearch`** and **`maxConcurrency`**.
5. Keep **Apify Proxy** on residential (the default) for the highest success rate on this German site.
6. Run, then export the dataset to CSV, JSON or Excel, or pull it via the Apify API, webhooks and integrations (Google Sheets, S3, your warehouse).

#### Example input

```json
{
  "searchUrls": [
    "https://www.wg-gesucht.de/wg-zimmer-in-Berlin.8.0.1.0.html",
    "https://www.wg-gesucht.de/wohnungen-in-Muenchen.90.2.1.0.html",
    "https://www.wg-gesucht.de/1-zimmer-wohnungen-in-Hamburg.55.1.1.0.html"
  ],
  "maxResults": 3000
}
````

#### Sample record

```json
{
  "id": "13507864",
  "title": "Dachgeschosswohnung 58m2 zur Zwischenmiete in Kreuzberg 36",
  "url": "https://www.wg-gesucht.de/wohnungen-in-Berlin-Kreuzberg.13507864.html",
  "listingType": "Apartment",
  "propertyType": "2-Zimmer-Wohnung",
  "rent": 1300,
  "currency": "EUR",
  "sizeSqm": 58,
  "rooms": 2,
  "city": "Berlin",
  "district": "Kreuzberg",
  "street": "Manteuffelstr",
  "availableFrom": "05.06.2026",
  "availableTo": null,
  "posterName": "Herr Can",
  "onlineStatus": "Online: 2 Minuten",
  "scrapedAt": "2026-06-05T15:31:24.950Z"
}
```

### FAQ

#### Do I need a WG-Gesucht account or API key?

No. The Actor reads public search-result data — no login and no token. It collects publicly available listing data; you are responsible for complying with WG-Gesucht's terms and your local regulations (including how you use any personal data).

#### Which categories are supported?

All of them — WG rooms (flatshares), 1-room flats, whole apartments, houses and sublets (Zwischenmiete). Just paste that category's search URL into `searchUrls`.

#### How do I filter by city, price, rooms or move-in date?

Apply the filters on WG-Gesucht itself, then copy the resulting URL. Every filter encoded in the URL is respected, and the Actor paginates the whole result set (often 50+ pages per city).

#### How many listings can I get per city?

A single big-city search (e.g. apartments in Berlin) spans 50+ pages — well over 1,000 listings. Use `maxResults` to cap the run, or `0` for everything.

#### What output formats are supported?

Every run produces a structured dataset you can export to JSON, CSV, Excel or XML, or access through the Apify API, webhooks and integrations.

#### Is this a WG-Gesucht API alternative?

Yes. WG-Gesucht has no public API, so this Actor works as a WG-Gesucht API alternative: it reads the public search results directly and gives you the structured listing data an API would, with no token needed.

#### How do I export WG-Gesucht data to CSV or JSON?

Run the Actor on your search URLs, then download the dataset as CSV, JSON, Excel or XML, or pull it via the Apify API. It's a no-code way to export WG-Gesucht data to CSV without writing a scraper.

#### Can I scrape WG-Gesucht without login?

Yes. The Actor scrapes WG-Gesucht without login and without an API key, reading only public, server-rendered listing cards across every German city.

### Scheduling & integration

Put this Actor on an Apify Schedule for a fresh WG-Gesucht listings feed every morning, straight to the Apify API, a webhook, Google Sheets, S3 or your warehouse. Chain searches across cities and categories to build a nationwide German rental dataset.

### Changelog

#### 2026-06-07

- Docs: added coverage for using this as a WG-Gesucht API alternative, exporting WG-Gesucht data to CSV/JSON, and scraping WG-Gesucht without login.

### License

Apache-2.0

# Actor input Schema

## `searchUrls` (type: `array`):

WG-Gesucht search URLs copied straight from the site. Pick a city and category (WG rooms, 1-room flats, apartments, houses), apply your filters, then paste the resulting URL. Examples: https://www.wg-gesucht.de/wohnungen-in-Berlin.8.2.1.0.html (apartments) or https://www.wg-gesucht.de/wg-zimmer-in-Muenchen.90.0.1.0.html (flatshare rooms).

## `maxResults` (type: `integer`):

Stop after this many listings across all search URLs. 0 = no limit (a single city search can span 50+ pages / 1,000+ listings).

## `maxResultsPerSearch` (type: `integer`):

Cap listings per individual search URL. 0 = no per-search cap.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Residential is recommended and is the default for a German site.

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

Apify Proxy settings. Residential gives the highest success rate on WG-Gesucht.

## `maxConcurrency` (type: `integer`):

How many search URLs to process in parallel.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.wg-gesucht.de/wohnungen-in-Berlin.8.2.1.0.html"
  ],
  "maxResults": 200,
  "maxResultsPerSearch": 0,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `id` (type: `string`):

Listing ID

## `title` (type: `string`):

Title

## `url` (type: `string`):

Listing URL

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

Listing type

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

Property type

## `rent` (type: `string`):

Rent in EUR

## `currency` (type: `string`):

Currency

## `sizeSqm` (type: `string`):

Size in square meters

## `rooms` (type: `string`):

Number of rooms

## `city` (type: `string`):

City

## `district` (type: `string`):

District / neighbourhood

## `street` (type: `string`):

Street

## `availableFrom` (type: `string`):

Available from date

## `availableTo` (type: `string`):

Available to date (for sublets)

## `posterName` (type: `string`):

Name of the person who posted the ad

## `onlineStatus` (type: `string`):

How recently the poster was online

## `image` (type: `string`):

Thumbnail image URL

## `sourceUrl` (type: `string`):

Search URL this listing came from

## `scrapedAt` (type: `string`):

Scraped at

# 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 = {
    "searchUrls": [
        "https://www.wg-gesucht.de/wohnungen-in-Berlin.8.2.1.0.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/wg-gesucht-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 = { "searchUrls": ["https://www.wg-gesucht.de/wohnungen-in-Berlin.8.2.1.0.html"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/wg-gesucht-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 '{
  "searchUrls": [
    "https://www.wg-gesucht.de/wohnungen-in-Berlin.8.2.1.0.html"
  ]
}' |
apify call logiover/wg-gesucht-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WG-Gesucht Scraper - German Flatshare & Rentals",
        "description": "WG-Gesucht API alternative: scrape German flatshare & apartment rental listings without login and export to CSV, JSON or Excel. No API key.",
        "version": "1.0",
        "x-build-id": "sIutAUM3s1jlxeyzc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~wg-gesucht-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-wg-gesucht-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/logiover~wg-gesucht-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-wg-gesucht-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/logiover~wg-gesucht-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-wg-gesucht-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": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "WG-Gesucht search URLs copied straight from the site. Pick a city and category (WG rooms, 1-room flats, apartments, houses), apply your filters, then paste the resulting URL. Examples: https://www.wg-gesucht.de/wohnungen-in-Berlin.8.2.1.0.html (apartments) or https://www.wg-gesucht.de/wg-zimmer-in-Muenchen.90.0.1.0.html (flatshare rooms).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many listings across all search URLs. 0 = no limit (a single city search can span 50+ pages / 1,000+ listings).",
                        "default": 200
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap listings per individual search URL. 0 = no per-search cap.",
                        "default": 0
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Residential is recommended and is the default for a German site.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Residential gives the highest success rate on WG-Gesucht.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent searches",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many search URLs to process in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```