# Pararius Scraper \[$1/1K💰] | Dutch Rentals | Expat Housing (`ahmed_jasarevic/pararius-nl-scraper`) Actor

Scrape Pararius.nl, the Netherlands's largest rental platform — rent, m², rooms, energy label, furnishing, availability, deposit, makelaar and photo galleries. Built for expat housing research, rental price monitoring and Dutch market analysis. $1 per 1,000 listings.

- **URL**: https://apify.com/ahmed_jasarevic/pararius-nl-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Pararius NL Scraper

Scrape **Pararius.nl** — the Netherlands' largest rental platform — for complete Dutch rental listings: monthly rent, m², rooms, furnishing, energy label, availability dates, deposit, letting agent (makelaar) and full photo galleries across Amsterdam, Rotterdam, Utrecht and every Dutch city.

Built for expat and relocation teams, rental price monitoring, Dutch real-estate market research and agencies building structured rental databases.

### Monitor Dutch Rental Prices and Build Expat Housing Datasets

- **Rental price monitoring** — track asking rents per city, neighbourhood, property type or furnishing level on a schedule.
- **Expat & relocation research** — English-first listings with furnished/semi-furnished filters, availability dates and m² for assignee housing.
- **Market intelligence** — analyse supply, energy labels, year built, deposits and days-on-market across Dutch cities.
- **Letting-agent (makelaar) leads** — every listing carries the letting agent's name and Pararius profile URL.
- **Structured rental database** — 28 normalized fields per listing plus the full Dutch features table, exportable as JSON/CSV/Excel.
- **Portfolio & comps** — feed comparable rental evidence into valuations or rent-setting models.

### How It Works

![How the Pararius Scraper works: search JSON and listing JSON-LD become rental rows with rent, surface, energy label and agent details.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-pararius-nl-scraper)

The Actor calls the same search XHR the Pararius frontend uses, 30 listings per page, then opens detail pages for their RealEstateListing JSON-LD and Dutch features table. Apify Unblocker proxies solve Cloudflare automatically.

Each row covers one listing with rent, address, rooms, surface, furnishing, availability, deposit, build year, energy label, features, agent profile, photos and coordinates.

No browser is launched. The Actor reads two structured surfaces:

1. **Search pages via Pararius' own JSON endpoint** — the same XHR the site's frontend makes (card data for up to 30 listings per page), following pagination up to `maxPagesPerSearch`.
2. **Detail pages via embedded JSON-LD** — each listing's `RealEstateListing` structured-data block plus the Dutch features table (Overdracht / Bouw / Oppervlakte en aantal kamers …) supply availability, postcode, rooms, m², furnishing, energy label, agent profile and the photo gallery.

Pararius sits behind a Cloudflare managed challenge; the Actor routes traffic through Apify's Unblocker proxies (which solve it automatically) and falls back to residential proxies on accounts without Unblocker access. Results are deduplicated — one record per listing.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `searchUrls` | array | No | Amsterdam rentals | Pararius search URLs, including filtered URLs (price / rooms / interior). Pagination followed automatically. |
| `listingUrls` | array | No | `[]` | Direct listing-detail URLs to scrape specific listings only. English `pararius.com` listing URLs are supported here. |
| `fetchDetails` | boolean | No | `true` | Visit each listing's detail page for the full record. `false` = search-card data only (faster/cheaper; each detail page is a billed event). |
| `maxListings` | integer | No | `50` | Max listings per run (hard cap 1000). |
| `maxPagesPerSearch` | integer | No | `3` | Pagination depth per search URL (30 listings per page; max 50 pages). |
| `proxyConfiguration` | object | No | Apify proxy (auto) | Pararius requires Unblocker proxies; leave as-is unless you use your own. |

### Output Fields

Default dataset — one item per listing (28 fields):

| Field | Description |
| --- | --- |
| `listingId`, `url`, `title` | Canonical Pararius listing identity |
| `propertyType` | Appartement / huis / studio / kamer … |
| `price` | Monthly rent (EUR, parsed number + raw text) |
| `address` | Street, postcode, city, district/neighborhood |
| `rooms`, `bedrooms`, `bathrooms` | Counts |
| `surfaceM2` | Living surface in m² |
| `furnishing` | Gemeubileerd / gestoffeerd / kaal … |
| `interiorFeatures` | Interior detail list |
| `availableFrom`, `availabilityText` | Availability (ISO where published; raw text like "Per direct" otherwise) |
| `offeredSince`, `status`, `datePosted` | Listing lifecycle |
| `yearBuilt`, `energyLabel`, `floorLevel` | Building details |
| `deposit` | Security deposit (EUR) |
| `featuresTable` | Full Dutch features table (Overdracht / Bouw / Oppervlakte en kamers …) |
| `agent` | Letting agent name + Pararius profile URL |
| `photos` | Full gallery URLs from the detail page |
| `geo` | Latitude/longitude when provided |
| `isFeatured`, `labels`, `scrapedAt` | Flags and timestamp |

### Example Input

```json
{
  "searchUrls": [{ "url": "https://www.pararius.nl/huurwoningen/amsterdam/1500-2500/2-kamers" }],
  "fetchDetails": true,
  "maxListings": 100,
  "maxPagesPerSearch": 5
}
```

Specific listings only (English site URLs also work):

```json
{
  "listingUrls": [{ "url": "https://www.pararius.nl/appartement-te-huur/amsterdam/40454c82/street" }],
  "fetchDetails": true
}
```

### Example Output

```json
{
  "listingId": "40454c82",
  "url": "https://www.pararius.nl/appartement-te-huur/amsterdam/40454c82/street",
  "title": "Modern 2-bedroom apartment near Vondelpark",
  "propertyType": "Appartement",
  "address": "StreetName 12, 1054 XX Amsterdam, Noord-Holland",
  "price": 2150,
  "rooms": 3,
  "bedrooms": 2,
  "bathrooms": 1,
  "surfaceM2": 78,
  "furnishing": "Gemeubileerd",
  "availableFrom": "2026-11-01",
  "availabilityText": "Per 1 november 2026",
  "offeredSince": "2026-10-10",
  "status": "Available",
  "yearBuilt": 1964,
  "energyLabel": "A",
  "floorLevel": "3",
  "deposit": 2150,
  "featuresTable": { "Overdracht": { "Vraagprijs": "€ 2.150 p.m." }, "Bouw": { "Soort": "Appartement" } },
  "agent": { "name": "Example Makelaardij", "profileUrl": "https://www.pararius.nl/makelaar/example" },
  "photos": ["https://media.pararius.nl/…"],
  "geo": { "lat": 52.3611, "lon": 4.8736 },
  "scrapedAt": "2026-10-18T09:00:00.000Z"
}
```

### Automate Rental Monitoring With Schedules & Webhooks

- **Schedule** daily or twice-daily runs on filtered search URLs (per city, price band, furnishing) to catch new listings and price changes first.
- **Webhooks** push each finished run into Slack, Google Sheets, Zapier or Make the moment new rental data lands.
- **API** — start runs and download datasets programmatically for pipeline integration.
- **Cost control** — set a maximum cost per run; the Actor stops gracefully when the limit is reached.

### Related Actors

Verified related actors on Apify that pair well with this one. All links point to real, publicly available actors.

- [Zillow Search Scraper](https://apify.com/maxcopell/zillow-scraper)
- [ImmoScout24 Scraper — .de/.ch/.at + Price-Cut Archive](https://apify.com/memo23/immobilienscout24-scraper)
- [Funda Scraper](https://apify.com/ivanvs/funda-scraper)
- [Pararius.nl Scraper](https://apify.com/memorable_alphabet/pararius-rentals)
- [Rightmove Scraper — UK Property & Sold Prices](https://apify.com/ahmed_jasarevic/rightmove-scraper)

### Frequently Asked Questions

#### Does Pararius have an official API?

No. Pararius (Pararius B.V., Amsterdam) publishes no public API — only the website. The Actor uses the same structured surfaces the site itself serves to visitors: the JSON search XHR the frontend calls and the JSON-LD `RealEstateListing` block embedded in each listing page. Paid third-party "Pararius APIs" exist, but they are resold scrapers of the same public site; this Actor keeps that pipeline inside Apify with pay-per-event pricing and no separate API subscription.

#### What is the best way to monitor Dutch rental prices?

Point `searchUrls` at filtered Pararius search pages (city + price band + rooms, e.g. `/huuurwoningen/amsterdam/1500-2500/2-kamers`), set `fetchDetails: false` for a cheap price/supply snapshot, and schedule the run daily or twice daily. Turn `fetchDetails` on for full records when you need m², energy label and furnishing.

#### How is Pararius different from Funda?

Funda dominates Dutch sales listings; Pararius leads the rental market and is the go-to platform for expats (English-first interface, furnished filters). For full Dutch coverage, pair this Actor with the Funda Scraper linked above.

#### Can I scrape English-language listings?

Yes. Listing-detail URLs from the English site (`pararius.com`) are supported through the `listingUrls` input; the Dutch site (`pararius.nl`) is used for search crawls.

#### How much does a run cost?

Pay per event: **$1 per 1,000 listings**, plus **$4 per 1,000 detail pages** when `fetchDetails` is on. 100 listings with full details cost 100 × ($0.001 + $0.004) = **$0.50**. Free accounts get a capped preview run; paying accounts get the full configured run.

#### Can an AI agent call this Actor?

Yes — it runs through the Apify API and MCP server with JSON input. See [For AI Agents & LLM Apps](#for-ai-agents--llm-apps) for the minimal call, output fields and billing rules.

#### Does the output include letting-agent (makelaar) contact data?

Each listing includes the letting agent's name and their Pararius profile URL. Contact details beyond that depend on what the agent publishes publicly on Pararius.

### For AI Agents & LLM Apps

Returns Dutch rental listings from Pararius.nl: rent, address/postcode, rooms, m², furnishing, energy label, availability, deposit, agent and photos.

Minimal input (Amsterdam rentals, full details):

```json
{ "searchUrls": [{ "url": "https://www.pararius.nl/huurwoningen/amsterdam" }], "maxListings": 25 }
```

Variant input (card-only price monitoring, no detail fetches):

```json
{ "searchUrls": [{ "url": "https://www.pararius.nl/huurwoningen/rotterdam/0-1500" }], "fetchDetails": false, "maxListings": 200 }
```

Output fields: `listingId`, `url`, `title`, `propertyType`, `price`, `address`, `rooms`, `bedrooms`, `bathrooms`, `surfaceM2`, `furnishing`, `interiorFeatures`, `availableFrom`, `availabilityText`, `offeredSince`, `status`, `yearBuilt`, `energyLabel`, `floorLevel`, `deposit`, `featuresTable`, `agent`, `photos`, `geo`, `isFeatured`, `labels`, `datePosted`, `scrapedAt`.

Behaviors an agent should know:

- `searchUrls` and `listingUrls` are alternative entry points (search crawl vs. specific listings).
- `fetchDetails: true` (default) adds one billed `detail-page` event ($4/1K) per listing; `false` returns search-card fields only.
- `maxListings` hard cap is 1000; `maxPagesPerSearch` max is 50 at 30 listings per page.
- Leave `proxyConfiguration` untouched: the Actor routes through Unblocker proxies to pass Pararius' Cloudflare challenge by default.
- English `pararius.com` URLs work only through `listingUrls`.
- Free accounts receive a capped preview run; paid accounts run the full configuration.

Billing: pay per event — `$0.001` per listing, `$0.004` per fetched detail page.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Pararius B.V. or pararius.nl. It accesses only publicly available listing pages — no login, no authenticated areas; the Cloudflare interstitial is handled through Apify's standard Unblocker proxy product rather than by breaking into protected account areas. Listing and agent data returned are whatever Pararius publishes to any visitor. You are responsible for your own compliance with Pararius' Terms of Service and with applicable data-protection law (including GDPR where natural persons' data may appear in listing descriptions or agent records); do not use personal contact data from the output for unsolicited commercial outreach in violation of applicable law such as GDPR, CAN-SPAM or TCPA.

### SEO Keywords

pararius scraper, pararius api, pararius alternative, dutch rental listings, rental data netherlands, amsterdam rental listings, rotterdam rental listings, expat housing amsterdam, dutch rental market data, rental price monitoring amsterdam, makelaar data, housing data netherlands, dutch property data, pararius.com scraper, furnished apartments amsterdam, huurwoningen data, rental listing export, energy label rental data

# Actor input Schema

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

Pararius search/listing-page URLs to crawl, e.g. https://www.pararius.nl/huurwoningen/amsterdam or filtered URLs like https://www.pararius.nl/huurwoningen/utrecht/0-1500/2-kamers. Pagination is followed automatically up to 'maxPagesPerSearch'.

## `listingUrls` (type: `array`):

Direct URLs of individual Pararius listings (e.g. https://www.pararius.nl/appartement-te-huur/amsterdam/40454c82/street). Use this to scrape specific listings only.

## `fetchDetails` (type: `boolean`):

Visit each listing's detail page for full data: availability date, postcode, rooms, m2, furnishing, energy label, letting agent profile, all photos. Set false to get search-card data only (faster/cheaper). Note: each detail page is charged as an extra paid event - see the Pricing tab.

## `maxListings` (type: `integer`):

Maximum number of rental listings to scrape in total.

## `maxPagesPerSearch` (type: `integer`):

Maximum number of pagination pages to follow per search URL (30 listings per page).

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

Proxy settings. Pararius sits behind a Cloudflare managed challenge — the actor automatically uses Apify's Unblocker proxies (which solve it), falling back to residential proxies. Leave as-is unless you have your own proxies.

## Actor input object example

```json
{
  "searchUrls": [
    {
      "url": "https://www.pararius.nl/huurwoningen/amsterdam"
    }
  ],
  "listingUrls": [],
  "fetchDetails": true,
  "maxListings": 50,
  "maxPagesPerSearch": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchUrls": [
        {
            "url": "https://www.pararius.nl/huurwoningen/amsterdam"
        }
    ],
    "listingUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchUrls": [{ "url": "https://www.pararius.nl/huurwoningen/amsterdam" }],
    "listingUrls": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/pararius-nl-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchUrls": [
    {
      "url": "https://www.pararius.nl/huurwoningen/amsterdam"
    }
  ],
  "listingUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call ahmed_jasarevic/pararius-nl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/pararius-nl-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dSpmkAui2rhHKFxQP/builds/2hU3KITRGNKgoXaZy/openapi.json