# Willhaben Scraper - Austrian Classifieds & Marketplace (`studio-amba/willhaben-scraper`) Actor

Scrape classified listings from Willhaben.at, Austria's largest marketplace. Search by keyword, category, and price range. Extract titles, prices, descriptions, images, location, and seller info. Covers classifieds, real estate, cars, and jobs. No login or cookies required.

- **URL**: https://apify.com/studio-amba/willhaben-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

### What does Willhaben Scraper do?

**Willhaben Scraper** extracts classified listing data from [Willhaben.at](https://www.willhaben.at), **Austria's largest online marketplace**. It covers all major sections: general classifieds (Kaufen & Verkaufen), real estate (Immobilien), cars (Autos), and jobs. Search by keyword, filter by category and price range, and get structured data including titles, prices, descriptions, images, seller info, and location details. No login or cookies required.

Use the Apify platform to run this scraper on a schedule, access results via API, or integrate with tools like Google Sheets, Zapier, Make, Slack, and more.

### Why use Willhaben Scraper?

- **Market research** — Track pricing trends for products, real estate, or vehicles across Austria
- **Competitive analysis** — Monitor competitor listings, pricing strategies, and product availability
- **Lead generation** — Find sellers, dealers, or job postings matching your criteria
- **Price monitoring** — Set up scheduled runs to track price changes over time
- **Data journalism** — Analyze listing patterns across Austrian regions and categories
- **Academic research** — Study marketplace dynamics, pricing behavior, and regional trends

### How to scrape Willhaben.at listings

1. Go to the Willhaben Scraper on Apify Store
2. Enter your search keyword (e.g. "laptop", "Wohnung Wien", "BMW")
3. Select a category (Marketplace, Real Estate, Cars, or Jobs)
4. Optionally set price filters and sorting
5. Set the maximum number of results you want
6. Click **Start** and wait for the results
7. Download your data as JSON, CSV, Excel, or access it via API

### Input

| Field | Type | Description |
|-------|------|-------------|
| `query` | String | Search keyword (e.g. "laptop", "iPhone 15") |
| `category` | String | Section to search: marketplace, real-estate, cars, jobs |
| `minPrice` | Number | Minimum price filter in EUR |
| `maxPrice` | Number | Maximum price filter in EUR |
| `sortBy` | String | Sort order: newest, cheapest, most-expensive |
| `maxResults` | Integer | Maximum listings to scrape (default: 100) |

See the **Input** tab for full details and default values.

### Output

The scraper produces structured JSON data for each listing. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "itemId": "1140062650",
    "title": "Laptop Rucksack",
    "description": "Verkaufe 2 Laptop Rucksacke Marke Axians unbenutzt.",
    "price": 15,
    "currency": "EUR",
    "priceType": "FIXED",
    "condition": null,
    "city": "Wien, 10. Bezirk, Favoriten",
    "state": "Wien",
    "sellerName": null,
    "sellerType": "PRIVATE",
    "imageUrl": "https://cache.willhaben.at/mmo/0/114/006/2650_-1520705034.jpg",
    "imageUrls": ["https://cache.willhaben.at/mmo/0/114/006/2650_-1520705034.jpg"],
    "category": "3275;3480;3486",
    "url": "https://www.willhaben.at/iad/kaufen-und-verkaufen/d/laptop-rucksack-1140062650/",
    "scrapedAt": "2026-04-06T20:14:17.993Z"
}
````

### Data fields

| Field | Description |
|-------|-------------|
| `itemId` | Unique Willhaben listing ID |
| `title` | Listing title |
| `description` | Full description text |
| `price` | Price in EUR (null if not specified) |
| `currency` | Always EUR |
| `priceType` | FIXED, NEGOTIABLE, FREE, or UNSPECIFIED |
| `condition` | Item condition (when available) |
| `city` | Seller city/district |
| `state` | Austrian state (Bundesland) |
| `sellerName` | Seller display name |
| `sellerType` | PRIVATE or DEALER |
| `imageUrl` | Main image URL |
| `imageUrls` | All image URLs |
| `category` | Category tree IDs |
| `url` | Direct link to listing |
| `scrapedAt` | When the data was scraped |

### How much does it cost to scrape Willhaben.at?

Willhaben Scraper is very lightweight — it uses fast HTTP requests (no browser needed), so costs are minimal. Scraping 1,000 listings typically costs less than $0.01 in Apify platform credits. The Actor uses approximately 128 MB of memory per run.

### Tips

- **Start small** — Test with 5-10 results first to verify the data matches your needs
- **Use category filters** — Narrow results to a specific section (marketplace, real estate, cars, jobs) for more relevant data
- **Price filtering** — Combine `minPrice` and `maxPrice` to focus on a specific price range
- **Scheduled runs** — Set up periodic runs to monitor new listings or price changes
- **No proxy needed** — Willhaben.at doesn't use aggressive anti-bot protection, so proxies are usually unnecessary

### FAQ and support

**Is it legal to scrape Willhaben.at?**
Web scraping of publicly available data is generally legal. This Actor only accesses publicly visible listing data — no login, cookies, or authentication required.

**How often is the data updated?**
Each run fetches live data directly from Willhaben.at. Schedule runs as frequently as needed.

**Can I scrape all categories?**
Yes — the Actor supports Marketplace (classifieds), Real Estate, Cars, and Jobs sections.

**Need help or a custom solution?**
Open an issue in the **Issues** tab or contact us for custom scraping solutions.

# Actor input Schema

## `query` (type: `string`):

Search term (e.g. 'laptop', 'iPhone 15', 'Wohnung Wien'). Leave empty to browse all listings.

## `category` (type: `string`):

Which Willhaben section to search.

## `minPrice` (type: `number`):

Minimum price filter in euros.

## `maxPrice` (type: `number`):

Maximum price filter in euros.

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

How to sort results.

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

Maximum number of listings to scrape. Each page has ~30 results.

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

Proxy settings. Usually not needed — Willhaben.at has no aggressive anti-bot protection.

## Actor input object example

```json
{
  "query": "laptop",
  "category": "marketplace",
  "sortBy": "newest",
  "maxResults": 100
}
```

# 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 = {
    "query": "laptop"
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/willhaben-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 = { "query": "laptop" }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/willhaben-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 '{
  "query": "laptop"
}' |
apify call studio-amba/willhaben-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Willhaben Scraper - Austrian Classifieds & Marketplace",
        "description": "Scrape classified listings from Willhaben.at, Austria's largest marketplace. Search by keyword, category, and price range. Extract titles, prices, descriptions, images, location, and seller info. Covers classifieds, real estate, cars, and jobs. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "8eh3ICfDIuv6DZB1Z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~willhaben-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-willhaben-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/studio-amba~willhaben-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-willhaben-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/studio-amba~willhaben-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-willhaben-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": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term (e.g. 'laptop', 'iPhone 15', 'Wohnung Wien'). Leave empty to browse all listings."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "marketplace",
                            "real-estate",
                            "cars",
                            "jobs"
                        ],
                        "type": "string",
                        "description": "Which Willhaben section to search.",
                        "default": "marketplace"
                    },
                    "minPrice": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum price filter in euros."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum price filter in euros."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "newest",
                            "cheapest",
                            "most-expensive"
                        ],
                        "type": "string",
                        "description": "How to sort results.",
                        "default": "newest"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. Each page has ~30 results.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Usually not needed — Willhaben.at has no aggressive anti-bot protection."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
