# athome.lu Scraper — Luxembourg Real Estate (Buy & Rent) (`haketa/athome-lu-scraper`) Actor

Scrape athome.lu property listings across Luxembourg + the Greater Region (FR/DE/BE border). Export price, surface, rooms, bedrooms, type, features, GPS coordinates, photos and the listing agency contact details. Buy & rent, no API key. Ideal for real-estate research, price monitoring & lead-gen.

- **URL**: https://apify.com/haketa/athome-lu-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 33.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## athome.lu Scraper 🏠 — Luxembourg Real Estate (Buy & Rent)

> Extract property listings from **athome.lu** — Luxembourg's #1 real-estate portal — covering the whole country **and the Greater Region** (French, German & Belgian border towns). Price, surface, rooms, features, GPS coordinates, photos and the **listing agency's contact details**. **No API key. No login.**

[![No API key](https://img.shields.io/badge/API%20key-not%20required-brightgreen)](#)
[![Buy & Rent](https://img.shields.io/badge/buy%20%26%20rent-supported-blue)](#)
[![Agency contacts](https://img.shields.io/badge/agency%20email%20%26%20phone-included-blueviolet)](#)
[![Export](https://img.shields.io/badge/export-JSON%20%7C%20CSV%20%7C%20Excel-informational)](#)
[![Speed](https://img.shields.io/badge/fast-pure%20HTTP-success)](#)

**athome.lu** is the leading property marketplace in **Luxembourg** — tens of thousands of apartments, houses, new-build projects and land for sale and rent, spanning the Grand Duchy and its cross-border **Greater Region**. This actor turns those listings into clean, structured **JSON / CSV / Excel**: every price, surface, room count, feature, map coordinate and photo — plus the agency behind each listing.

Pick **buy** or **rent**, press **Start**, and get rows.

---

### 📑 Table of contents

- [Why this scraper](#-why-this-scraper)
- [What you can scrape](#-what-you-can-scrape)
- [Quick start](#-quick-start)
- [Input examples](#-input-examples)
- [Output example](#-output-example)
- [Field reference & fill rates](#-field-reference--fill-rates)
- [Who uses this & why](#-who-uses-this--why)
- [Use cases](#-use-cases)
- [FAQ](#-faq)
- [Legal & responsible use](#-legal--responsible-use)

---

### ✨ Why this scraper

| | |
|---|---|
| 🔑 **No API key, no login** | Just choose buy/rent or paste a search URL. |
| 🇱🇺 **Luxembourg + Greater Region** | Not only the Grand Duchy — also the French, German and Belgian border towns cross-border commuters actually search. |
| 💰 **Full listing detail** | Price, price/m², surface, rooms, bedrooms, bathrooms, floor, property type, new-build flag and dozens of features. |
| 📍 **GPS coordinates** | Latitude, longitude, city and postal code on every listing — ready to map. |
| 🏢 **Agency contacts** | The listing agency's **email, phone and website** — great for lead generation and outreach. |
| 🖼️ **Photos included** | An array of full-resolution photo URLs per listing. |
| ⚡ **Fast & cheap** | Lightweight, pure-HTTP — hundreds of listings in seconds. You only pay for what you keep. |

> 💡 **Built for the Greater Region.** Luxembourg's housing market doesn't stop at the border — a huge share of demand comes from commuters in Thionville, Trier, Arlon and beyond. This scraper returns those cross-border listings too, tagged by country.

---

### 📦 What you can scrape

<table>
<tr><td>

**🏡 Property**
- Title & full description
- Type (apartment, house, duplex, studio, land, project…)
- New-build flag & building year
- Rooms, bedrooms, bathrooms, floor

</td><td>

**💰 Price & size**
- Price (€) + price/m²
- Price range for projects
- Living surface & land surface
- Charges

</td></tr>
<tr><td>

**📍 Location**
- City, postal code, street
- Country (LU / FR / DE / BE)
- Latitude & longitude

</td><td>

**🏢 Agency & media**
- Agency email, phone, website
- Photo URLs
- Direct listing link

</td></tr>
</table>

**Features captured:** garden · elevator · pool · terrace · balcony · basement · attic · garages · parking · kitchen type · and more.

---

### 🚀 Quick start

1. Open the **Input** tab.
2. Type one or more **locations** — just the town name (e.g. `Luxembourg`, `Esch-sur-Alzette`). Use `Luxembourg` for the whole country.
3. Choose **Buy or rent**.
4. *(Optional)* Add filters — price, bedrooms, surface, property type.
5. Press **Start** ▶️

That's it. Leave everything on defaults and you'll get listings for sale across Luxembourg.

---

### 🧾 Input examples

**All apartments for rent in specific towns, 2+ bedrooms, up to €2,500:**

```json
{
  "locations": ["Esch-sur-Alzette", "Differdange"],
  "transactionType": "rent",
  "priceMax": 2500,
  "minBedrooms": 2,
  "propertyTypes": ["Apartment"],
  "maxItems": 500
}
````

**Everything for sale across Luxembourg (buy):**

```json
{ "locations": ["Luxembourg"], "transactionType": "buy", "maxItems": 1000 }
```

**Both buy and rent, houses only:**

```json
{
  "locations": ["Luxembourg"],
  "transactionType": "both",
  "propertyTypes": ["House"],
  "minSurface": 120
}
```

**Cross-border towns in the Greater Region:**

```json
{ "locations": ["Thionville", "Trier"], "transactionType": "buy" }
```

> 🔎 **Just type the town name.** The actor resolves it automatically — no codes or URLs to hunt down. Use `Luxembourg` for the whole country.

***

### 📤 Output example

```json
{
  "id": 8682741,
  "url": "https://www.athome.lu/en/rent/apartment/hayange/id-8682741.html",
  "title": "Bright 2-bedroom apartment with terrace",
  "transactionType": "rent",
  "propertyType": "flat",
  "propertySubType": "Apartment",
  "isNewBuild": false,
  "price": 1450,
  "pricePerM2": 20.8,
  "chargesPrice": 150,
  "surface": 69.67,
  "rooms": 3,
  "bedrooms": 2,
  "bathrooms": 1,
  "floor": 2,
  "hasGarden": false,
  "hasElevator": true,
  "hasTerrace": true,
  "garages": 1,
  "city": "Hayange",
  "postalCode": "57700",
  "country": "fr",
  "latitude": 49.33,
  "longitude": 6.06,
  "agencyEmail": "contact@example-agency.lu",
  "agencyPhone": "+352 12 34 56",
  "agencyWebsite": "https://www.example-agency.lu",
  "photoCount": 12,
  "photos": ["https://i1.static.athome.eu/images/annonces2/image_/..."],
  "description": "Superbly located apartment...",
  "scrapedAt": "2026-07-26T10:00:00.000Z"
}
```

***

### 📊 Field reference & fill rates

Legend: 🟢 almost always present · 🟡 present when available · ⚪ only when you enable the option

| Field | Fill | Description |
|---|:---:|---|
| `id` / `url` | 🟢 | Listing id and link |
| `title` | 🟢 | Listing title |
| `transactionType` | 🟢 | buy / rent |
| `propertyType` / `propertySubType` | 🟢 | Category (apartment, house, project…) |
| `isNewBuild` / `buildingYear` | 🟡 | New-build flag and year |
| `price` | 🟢 | Price in € (empty only for projects with a range) |
| `priceMin` / `priceMax` | 🟡 | Price range (new-build projects) |
| `pricePerM2` / `chargesPrice` | 🟡 | Unit price and monthly charges |
| `surface` | 🟢 | Living surface (m²) |
| `rooms` / `bedrooms` / `bathrooms` | 🟢 | Room counts |
| `floor` | 🟡 | Floor number |
| `hasGarden`, `hasElevator`, `hasPool`, `hasTerrace`, `hasBalcony`, `hasBasement`, `hasAttic`, `garages`, `carparks`, `kitchenType` | 🟡 | Features |
| `city` / `postalCode` / `street` | 🟢 | Address parts |
| `country` | 🟢 | LU / FR / DE / BE (Greater Region) |
| `latitude` / `longitude` | 🟢 | Map coordinates |
| `agencyEmail` | 🟢 | Listing agency email |
| `agencyPhone` / `agencyWebsite` | 🟡 | Agency phone & site |
| `photos` | ⚪ | Photo URLs — on by default |
| `description` | ⚪ | Listing description — on by default |

***

### 🎯 Who uses this & why

| Persona | What they pull | Why |
|---|---|---|
| 🏢 **Real-estate agencies & portals** | Whole market, buy + rent | Feed CRMs, compare inventory, spot new listings |
| 📈 **Investors & analysts** | Price, surface, price/m², location | Benchmark the market and find opportunities |
| 🤝 **Lead-gen & proptech** | Agency email, phone, website | Build agency contact lists for outreach |
| 🧭 **Relocation & expat services** | Rentals by area + coordinates | Help cross-border commuters and newcomers find homes |
| 🗺️ **Data & GIS teams** | Coordinates + attributes | Map listings and run spatial analysis |
| 🏦 **Banks & appraisers** | Price + surface + type | Support valuations and market reports |

***

### 💡 Use cases

- **Market monitoring** — track prices, new listings and time-on-market across Luxembourg and the border regions.
- **Agency lead generation** — collect agency email/phone/website to power B2B outreach.
- **Price & yield analysis** — combine price, surface and price/m² to model returns.
- **Relocation tools** — surface rentals near the border for cross-border commuters.
- **Comparable-sales research** — pull like-for-like properties by type, size and location.
- **Mapping & GIS** — plot listings by coordinates for heatmaps and catchment studies.

> ⏱️ **Automate it.** Add a **Schedule** to re-run a saved search every morning and capture new listings the moment they appear.

***

### ❓ FAQ

<details>
<summary><b>Do I need an account or API key?</b></summary>

No. The actor reads public listing pages — nothing to register, no login, no key.

</details>

<details>
<summary><b>Does it cover only Luxembourg?</b></summary>

It covers Luxembourg **and** the cross-border Greater Region (French, German and Belgian border towns), which appear on athome.lu. Each listing is tagged with its `country`.

</details>

<details>
<summary><b>How do I scrape a specific town?</b></summary>

Just type its name in **Locations** (e.g. `Esch-sur-Alzette`, `Differdange`). You can add several at once. The actor resolves each name automatically — no codes or URLs needed.

</details>

<details>
<summary><b>Why do some listings have no price?</b></summary>

New-build **projects** often show a price range instead of a single price — you'll find it in `priceMin` / `priceMax`. Regular listings have a single `price`.

</details>

<details>
<summary><b>Are agency contact details always included?</b></summary>

An agency email is available on the large majority of listings; phone and website are included when the agency publishes them.

</details>

<details>
<summary><b>What export formats are supported?</b></summary>

JSON, CSV, Excel, HTML table and RSS — from the dataset or via the Apify API.

</details>

***

### ⚖️ Legal & responsible use

This tool collects **publicly available** real-estate listing information — the same data any visitor can see on the public site. It does not access private data, log in, or bypass authentication.

You are responsible for how you use the data. Please:

- Respect the site's terms of service and robots policies.
- Comply with applicable laws, including data-protection rules such as **GDPR** when handling any personal data (e.g. agency contact details).
- Use the data for lawful purposes — research, analytics, and legitimate business outreach — not spam or harassment.

If you're unsure whether your use case is permitted, seek legal advice. This actor is provided for lawful data-collection purposes only.

***

#### 🔎 Also searched as

athome scraper · athome.lu scraper · Luxembourg real estate scraper · Luxembourg property scraper · athome.lu API · Luxembourg rentals scraper · Luxembourg apartments for sale · Greater Region property data · immo Luxembourg scraper · property listings Luxembourg

***

*Made for agencies, investors, proptech and data teams who need clean Luxembourg property data fast. Want another field added? Open an issue on the actor's **Issues** tab.*

# Actor input Schema

## `transactionType` (type: `string`):

Which listings to scrape when you don't paste your own search URLs.

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

Towns or areas to search — just type the name (e.g. Luxembourg, Esch-sur-Alzette, Differdange). Use "Luxembourg" for the whole country + Greater Region. Cross-border towns like Thionville or Trier work too.

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

Keep only listings at or above this price (€). 0 = no filter.

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

Keep only listings at or below this price (€). 0 = no filter.

## `minBedrooms` (type: `integer`):

Keep only listings with at least this many bedrooms. 0 = no filter.

## `minSurface` (type: `integer`):

Keep only listings with at least this living surface. 0 = no filter.

## `propertyTypes` (type: `array`):

Keep only these property types (e.g. Apartment, House, Duplex, Studio, Detached house). Leave empty for all.

## `includeDescription` (type: `boolean`):

Add the listing description text to each record.

## `includePhotos` (type: `boolean`):

Add an array of photo URLs to each record.

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

Overall cap on the number of listings to scrape.

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

How many result pages to fetch in parallel. Recommended: 6–12.

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

Proxy settings. The default (Apify Proxy) works out of the box.

## Actor input object example

```json
{
  "transactionType": "buy",
  "locations": [
    "Luxembourg",
    "Esch-sur-Alzette"
  ],
  "priceMin": 0,
  "priceMax": 0,
  "minBedrooms": 0,
  "minSurface": 0,
  "propertyTypes": [
    "Apartment",
    "House"
  ],
  "includeDescription": true,
  "includePhotos": true,
  "maxItems": 1000,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Download every listing (JSON, CSV, Excel).

## `runUrl` (type: `string`):

Open this run in the Apify Console.

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

Listing title

## `transactionType` (type: `string`):

buy or rent

## `propertySubType` (type: `string`):

Apartment, House, etc.

## `price` (type: `string`):

Price in EUR

## `surface` (type: `string`):

Living surface

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

Room count

## `bedrooms` (type: `string`):

Bedroom count

## `bathrooms` (type: `string`):

Bathroom count

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

City / town

## `postalCode` (type: `string`):

Postal code

## `country` (type: `string`):

lu / fr / de / be

## `agencyEmail` (type: `string`):

Listing agency email

## `agencyPhone` (type: `string`):

Listing agency phone

## `agencyWebsite` (type: `string`):

Listing agency website

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

Listing URL

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

ISO 8601 timestamp

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "locations": [
        "Luxembourg"
    ],
    "propertyTypes": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/athome-lu-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "locations": ["Luxembourg"],
    "propertyTypes": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/athome-lu-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "locations": [
    "Luxembourg"
  ],
  "propertyTypes": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/athome-lu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "athome.lu Scraper — Luxembourg Real Estate (Buy & Rent)",
        "description": "Scrape athome.lu property listings across Luxembourg + the Greater Region (FR/DE/BE border). Export price, surface, rooms, bedrooms, type, features, GPS coordinates, photos and the listing agency contact details. Buy & rent, no API key. Ideal for real-estate research, price monitoring & lead-gen.",
        "version": "0.1",
        "x-build-id": "TeRGGAiH1Xk2t38RX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~athome-lu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-athome-lu-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/haketa~athome-lu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-athome-lu-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/haketa~athome-lu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-athome-lu-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": {
                    "transactionType": {
                        "title": "🏷️ Buy or rent",
                        "enum": [
                            "buy",
                            "rent",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which listings to scrape when you don't paste your own search URLs.",
                        "default": "buy"
                    },
                    "locations": {
                        "title": "📍 Locations",
                        "type": "array",
                        "description": "Towns or areas to search — just type the name (e.g. Luxembourg, Esch-sur-Alzette, Differdange). Use \"Luxembourg\" for the whole country + Greater Region. Cross-border towns like Thionville or Trier work too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "💰 Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings at or above this price (€). 0 = no filter.",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "💰 Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings at or below this price (€). 0 = no filter.",
                        "default": 0
                    },
                    "minBedrooms": {
                        "title": "🛏️ Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings with at least this many bedrooms. 0 = no filter.",
                        "default": 0
                    },
                    "minSurface": {
                        "title": "📐 Min surface (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings with at least this living surface. 0 = no filter.",
                        "default": 0
                    },
                    "propertyTypes": {
                        "title": "🏠 Property types",
                        "type": "array",
                        "description": "Keep only these property types (e.g. Apartment, House, Duplex, Studio, Detached house). Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDescription": {
                        "title": "📝 Include description",
                        "type": "boolean",
                        "description": "Add the listing description text to each record.",
                        "default": true
                    },
                    "includePhotos": {
                        "title": "🖼️ Include photo URLs",
                        "type": "boolean",
                        "description": "Add an array of photo URLs to each record.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Overall cap on the number of listings to scrape.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many result pages to fetch in parallel. Recommended: 6–12.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The default (Apify Proxy) works out of the box.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
