# Pararius Scraper - Dutch Rental Listings & Prices (`studio-amba/pararius-scraper`) Actor

Scrape rental and sale listings from Pararius.nl, the Netherlands' #2 property portal. Extract prices, addresses, property details, photos, agency info, and availability. No login or cookies required.

- **URL**: https://apify.com/studio-amba/pararius-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 4 total users, 2 monthly users, 37.5% 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

## Pararius Scraper

Scrape rental and sale property listings from [Pararius.nl](https://www.pararius.nl), the Netherlands' second-largest real estate portal focused on the private rental market.

Extract monthly rent, addresses, surface area, number of rooms, furnished status, availability dates, property photos, descriptions, and agency info. Works with both rental (huurwoningen) and sale (koopwoningen) listings across all Dutch cities.

No login or cookies required.

### How to scrape Pararius data

1. **Go to** [this actor's page on Apify](https://apify.com/store) and click "Start".
2. **Enter a city name** in the `searchQuery` field (e.g., `amsterdam`, `rotterdam`, `utrecht`, `den-haag`).
3. **Select listing type** — `huurwoningen` (rentals) or `koopwoningen` (sale).
4. **Set max results** to control how many listings you want (default: 100).
5. **Configure proxy** — Residential proxies with NL country code are strongly recommended.
6. **Run the actor** and download your data as JSON, CSV, or Excel.

Alternatively, provide specific Pararius URLs via the `startUrls` field to scrape particular pages or individual listings.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `amsterdam` | City name in Dutch. Used to build the search URL. |
| `listingType` | enum | `huurwoningen` | `huurwoningen` (rent) or `koopwoningen` (sale). |
| `startUrls` | array | — | Specific Pararius URLs to scrape. Overrides `searchQuery`. |
| `maxResults` | integer | 100 | Maximum number of listings to return (1 to 10,000). |
| `proxyConfiguration` | object | Residential NL | Proxy settings. Residential proxies recommended. |

### Output format

Each listing includes the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Property listing title |
| `price` | number | Monthly rent or sale price in EUR |
| `currency` | string | Currency code (always EUR) |
| `listingType` | string | `rent` or `sale` |
| `propertyType` | string | apartment, house, studio, room, etc. |
| `address` | string | Street address |
| `city` | string | City name |
| `neighborhood` | string | Neighborhood or district |
| `postalCode` | string | Dutch postal code (e.g., 1012 AB) |
| `surface` | number | Living area in square meters |
| `rooms` | number | Total number of rooms |
| `bedrooms` | number | Number of bedrooms |
| `furnished` | string | Furnished, unfurnished, upholstered, etc. |
| `availableFrom` | string | Availability date |
| `description` | string | Full listing description |
| `agencyName` | string | Real estate agency name |
| `agencyUrl` | string | Agency profile URL on Pararius |
| `imageUrl` | string | Primary photo URL |
| `imageUrls` | array | All listing photo URLs |
| `url` | string | Full listing URL on Pararius |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was scraped |

### Example output

```json
{
    "title": "Apartment Prinsengracht",
    "price": 1850,
    "currency": "EUR",
    "listingType": "rent",
    "propertyType": "Appartement",
    "address": "Prinsengracht 123",
    "city": "Amsterdam",
    "neighborhood": "Jordaan",
    "postalCode": "1015 DT",
    "surface": 75,
    "rooms": 3,
    "bedrooms": 2,
    "furnished": "Gemeubileerd",
    "availableFrom": "Per direct",
    "description": "Prachtig gerenoveerd appartement aan de Prinsengracht...",
    "agencyName": "Amsterdam Housing Agency",
    "agencyUrl": "https://www.pararius.nl/makelaardij/amsterdam-housing-agency",
    "imageUrl": "https://images.pararius.nl/photo/123456.jpg",
    "imageUrls": [
        "https://images.pararius.nl/photo/123456.jpg",
        "https://images.pararius.nl/photo/123457.jpg"
    ],
    "url": "https://www.pararius.nl/huurwoning/amsterdam/appartement-prinsengracht-123456",
    "scrapedAt": "2026-05-29T12:00:00.000Z"
}
````

### Supported cities

Pararius covers all cities in the Netherlands. Common searches include:

- Amsterdam, Rotterdam, Den Haag (The Hague), Utrecht, Eindhoven
- Groningen, Tilburg, Almere, Breda, Nijmegen
- Haarlem, Arnhem, Leiden, Maastricht, Delft

Enter the Dutch city name in the `searchQuery` field (e.g., `den-haag` instead of "The Hague").

### Proxy configuration

Pararius uses anti-bot protection that blocks datacenter IP addresses. **Residential proxies with NL country code are strongly recommended** for reliable scraping.

The default configuration uses:

- Apify Proxy residential group
- Country: NL (Netherlands)

If you experience blocks or empty results, try:

- Reducing `maxResults` to smaller batches
- Using residential proxies from a different provider
- Adding delays between requests

### Use cases

- **Rental market analysis** — Track average rents by city, neighborhood, or property type across the Netherlands.
- **Property monitoring** — Set up scheduled runs to detect new listings matching your criteria.
- **Real estate investment** — Compare rental yields across Dutch cities and neighborhoods.
- **Academic research** — Collect housing market data for urban planning or economics studies.
- **Relocation planning** — Quickly scan available rentals in your target Dutch city.

### Integrations

Connect this actor with other tools via Apify integrations:

- **Google Sheets** — Automatically export listings to a spreadsheet.
- **Slack / Email** — Get notified when new listings match your criteria.
- **Zapier / Make** — Connect to 1000+ other apps for custom workflows.
- **API** — Access results programmatically via the Apify API.

### Limitations

- Pararius enforces rate limiting and bot detection. Residential proxies are essential.
- Very large scraping runs (5000+ listings) should be split across multiple runs.
- Some listing details may only be available on the detail page, not in search results.
- Listing availability can change quickly — data reflects the state at scrape time.

### Legal and ethical use

This actor is designed for legitimate data collection purposes such as market research, academic study, and personal property search. Always comply with Pararius's terms of service and applicable data protection regulations when using scraped data.

# Actor input Schema

## `searchQuery` (type: `string`):

City name in Dutch (e.g. 'amsterdam', 'rotterdam', 'utrecht', 'den-haag'). Used to build the search URL.

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

Filter by rent (huurwoningen) or buy (koopwoningen).

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

Provide specific Pararius URLs to scrape. Overrides searchQuery when provided. Supports both search pages and detail pages.

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

Maximum number of listings to return.

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

Proxy settings. Residential proxies with NL country are strongly recommended for Pararius.

## Actor input object example

```json
{
  "searchQuery": "amsterdam",
  "listingType": "huurwoningen",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}
```

# 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 = {
    "searchQuery": "amsterdam",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "NL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/pararius-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 = {
    "searchQuery": "amsterdam",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/pararius-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 '{
  "searchQuery": "amsterdam",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}' |
apify call studio-amba/pararius-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pararius Scraper - Dutch Rental Listings & Prices",
        "description": "Scrape rental and sale listings from Pararius.nl, the Netherlands' #2 property portal. Extract prices, addresses, property details, photos, agency info, and availability. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "60q8tgNVnvuPev7P2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~pararius-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-pararius-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~pararius-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-pararius-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~pararius-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-pararius-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": {
                    "searchQuery": {
                        "title": "City or Location",
                        "type": "string",
                        "description": "City name in Dutch (e.g. 'amsterdam', 'rotterdam', 'utrecht', 'den-haag'). Used to build the search URL.",
                        "default": "amsterdam"
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "huurwoningen",
                            "koopwoningen"
                        ],
                        "type": "string",
                        "description": "Filter by rent (huurwoningen) or buy (koopwoningen).",
                        "default": "huurwoningen"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Provide specific Pararius URLs to scrape. Overrides searchQuery when provided. Supports both search pages and detail pages.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Pararius URL to scrape"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies with NL country are strongly recommended for Pararius."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
