# Pararius Scraper - Netherlands Rental Listings (`benthepythondev/pararius-scraper`) Actor

Scrape Pararius (NL rental portal): price, address, postcode, rooms, surface area, furnishing, letting agent name & profile URL, image and listing URL. Search by Dutch city or paste a Pararius URL.

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

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🏠 Pararius Scraper - Netherlands Rental Listings

Scrape rental property listings from **Pararius**, one of the largest rental housing portals in the Netherlands, in clean, structured form. For every listing you get the **price, full address, postcode, number of rooms, surface area (m²), furnishing status, the letting agent's name and profile URL, the photo and the listing link** — ready to filter, dedupe, enrich or load into your CRM. Search by Dutch city (Amsterdam, Rotterdam, The Hague, Utrecht and more) or paste a Pararius search URL. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🔎 What is the Pararius Scraper?

Pararius lists tens of thousands of rental apartments, houses, studios and rooms across the Netherlands. This Actor turns those search-results pages into a structured dataset so you can monitor the Dutch rental market at scale instead of refreshing the site by hand. It loads the search pages exactly like a real Dutch visitor (through residential Netherlands proxies) and reads the data Pararius renders into each listing card, so the output is fast and reliable.

#### What data does it extract?

- **Listing id** — Pararius's own listing reference, perfect for deduplication.
- **URL** — direct link to the full listing on Pararius.
- **Title / address** — e.g. "Flat Sarphatipark", "House Van Speijkstraat 33".
- **Price** — numeric monthly rent plus the raw price string and currency.
- **Postcode, city & neighbourhood** — parsed from the listing (e.g. `1073CP`, `Amsterdam`, `Oude Pijp`).
- **Rooms** — number of rooms.
- **Surface area** — living area in m².
- **Interior** — furnishing status (Furnished, Upholstered, Shell).
- **Property type** — Apartment, House, Room, Studio.
- **Letting agent** — the agency / makelaar **name and profile URL** (lead-generation gold).
- **Image** — main listing photo (CDN URL).
- **Label** — "New", "Highlighted" badges where present.

### ⬇️ Input

| Field | Type | Description |
|-------|------|-------------|
| `cities` | array | Dutch city names to search, e.g. `amsterdam`, `rotterdam`, `den-haag`, `utrecht`. English names like "The Hague" are mapped automatically. |
| `propertyType` | string | Rental section for the cities above: `apartments`, `houses`, `rooms` or `studios`. |
| `searchUrls` | array | Full Pararius search-results URLs to scrape exactly (e.g. a price-filtered search). Used in addition to any cities. |
| `maxResults` | integer | Maximum listings to return per city / URL. |
| `useResidentialProxy` | boolean | Route through Apify RESIDENTIAL Netherlands proxies to reliably pass Cloudflare. Recommended ON. |

#### Example input

```json
{
  "cities": ["amsterdam", "rotterdam"],
  "propertyType": "apartments",
  "maxResults": 50,
  "useResidentialProxy": true
}
````

### ⬆️ Output

Each result is one rental listing:

```json
{
  "id": "32cc10da",
  "url": "https://www.pararius.com/apartment-for-rent/amsterdam/32cc10da/sarphatipark",
  "title": "Flat Sarphatipark",
  "property_type": "Flat",
  "listing_type": "rent",
  "price": 7000,
  "price_raw": "€7,000 pcm",
  "currency": "EUR",
  "price_period": "month",
  "rooms": 4,
  "area_sqm": 200,
  "interior": "Furnished",
  "address": "Flat Sarphatipark",
  "postcode": "1073CP",
  "city": "Amsterdam",
  "neighbourhood": "Oude Pijp",
  "country": "NL",
  "agent": "Out Amsterdam",
  "agent_url": "https://www.pararius.com/real-estate-agents/amsterdam/out-amsterdam",
  "image": "https://casco-media-prod.global.ssl.fastly.net/.../image.jpg",
  "label": "Highlighted",
  "query": "amsterdam"
}
```

### 💡 Use cases

- 🏙️ **Rental market research** — track asking rents, m² prices and supply per city and neighbourhood over time.
- 🤝 **Letting-agent lead lists** — build a directory of active makelaars/agencies with their profile URLs for B2B outreach.
- 🔔 **New-listing alerts** — run on a schedule and pipe fresh listings into Slack, email or a sheet to act before they're gone.
- 📊 **Enrichment & dashboards** — feed normalized listings into BI tools, pricing models or relocation services.

### ❓ FAQ

**Which Pararius listings does it cover?** Dutch rental listings — apartments, houses, rooms and studios — by city or via any Pararius search URL.

**Can I filter by price, bedrooms or furnishing?** Yes — build the filtered search on Pararius, copy the resulting URL, and paste it into `searchUrls`. The Actor scrapes exactly that filtered result set.

**How do I scrape The Hague?** Use `den-haag` (or just type "The Hague" — it is mapped automatically).

**Does it return the estate agent / makelaar?** Yes. Every listing includes the letting agency name and its Pararius profile URL, which is ideal for lead generation.

**Does it return GPS coordinates?** Pararius does not expose per-listing coordinates on its search pages, so they are not included. The postcode + address pinpoint each property and can be geocoded downstream if needed.

**How many results can I get?** As many as the search returns — paginate up to `maxResults`. Use multiple cities or URLs to cover the whole country.

**Why use a residential proxy?** Pararius sits behind Cloudflare. Residential Netherlands proxies let the Actor load pages like a local visitor, which keeps it reliable. Leave `useResidentialProxy` on.

**In what formats can I export?** JSON, CSV, Excel, HTML or via the API — and you can connect it to Make, Zapier or n8n.

**Is it legal?** This Actor collects only publicly available listing information. It does not access private or login-gated data. You are responsible for using the data in line with Pararius's terms, the GDPR and any applicable local laws — particularly when handling agent contact details, which must be used lawfully (e.g. legitimate B2B interest) and not for spam.

### 🔗 You might also like

- 🇳🇱 **Funda Scraper** — the Netherlands' #1 buy & rent property portal.
- 🇩🇪 **Kleinanzeigen / ImmobilienScout24 Scrapers** — German real estate.
- 🇬🇧 **Rightmove Scraper** — UK property for sale and to rent.
- 🇪🇸 **Idealista Scraper** — Spanish property listings.

**Keywords:** pararius scraper, pararius api, netherlands rental scraper, dutch rental listings, amsterdam apartments scraper, rotterdam rentals, den haag rentals, huurwoningen scraper, real estate scraper netherlands, makelaar leads, rental market data, property data netherlands, huur scraper, pararius data export, nl property api, rental listings json, letting agent leads, apartment scraper netherlands.

# Actor input Schema

## `cities` (type: `array`):

Dutch city names to search on Pararius, e.g. 'amsterdam', 'rotterdam', 'den-haag', 'utrecht'. English names like 'The Hague' are mapped automatically.

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

Which rental section to scrape for the cities above.

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

Full Pararius search-results URLs to scrape exactly (e.g. https://www.pararius.com/apartments/amsterdam/0-1500). Used in addition to any cities.

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

Maximum listings to return per city / URL.

## `useResidentialProxy` (type: `boolean`):

Route requests through Apify RESIDENTIAL Netherlands proxies to reliably pass Cloudflare. Recommended ON.

## Actor input object example

```json
{
  "cities": [
    "amsterdam"
  ],
  "propertyType": "apartments",
  "maxResults": 10,
  "useResidentialProxy": true
}
```

# 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 = {
    "cities": [
        "amsterdam"
    ],
    "propertyType": "apartments",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "cities": ["amsterdam"],
    "propertyType": "apartments",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/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 '{
  "cities": [
    "amsterdam"
  ],
  "propertyType": "apartments",
  "maxResults": 10
}' |
apify call benthepythondev/pararius-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pararius Scraper - Netherlands Rental Listings",
        "description": "Scrape Pararius (NL rental portal): price, address, postcode, rooms, surface area, furnishing, letting agent name & profile URL, image and listing URL. Search by Dutch city or paste a Pararius URL.",
        "version": "1.0",
        "x-build-id": "0QbdYJyzlmmdsizIA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~pararius-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-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/benthepythondev~pararius-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-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/benthepythondev~pararius-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-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": {
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Dutch city names to search on Pararius, e.g. 'amsterdam', 'rotterdam', 'den-haag', 'utrecht'. English names like 'The Hague' are mapped automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "apartments",
                            "houses",
                            "rooms",
                            "studios"
                        ],
                        "type": "string",
                        "description": "Which rental section to scrape for the cities above.",
                        "default": "apartments"
                    },
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Full Pararius search-results URLs to scrape exactly (e.g. https://www.pararius.com/apartments/amsterdam/0-1500). Used in addition to any cities.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum listings to return per city / URL.",
                        "default": 50
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxy (recommended)",
                        "type": "boolean",
                        "description": "Route requests through Apify RESIDENTIAL Netherlands proxies to reliably pass Cloudflare. Recommended ON.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```