# Kamernet Scraper - Dutch Rooms and Rentals (`studio-amba/kamernet-scraper`) Actor

Scrape rooms, studios and apartments for rent from Kamernet.nl. Get rent, deposit, size, furnishing, postal code, coordinates, availability dates, house rules and the full listing text for any Dutch city.

- **URL**: https://apify.com/studio-amba/kamernet-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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

## Kamernet Scraper

Scrape rooms, studios and apartments for rent from Kamernet.nl, a large Dutch rental platform with a focus on rooms and student housing. Each listing comes back as one structured row: title, monthly rent, deposit, size, furnishing, street, postal code, coordinates, availability dates, house rules and the full listing text.

### Why use this actor?

- Covers rooms, studios and apartments, for one city or the whole Netherlands.
- Gives the postal code and coordinates of every listing, so listings can be placed on a map.
- Gives the full listing text, deposit, availability dates and house rules such as pets and smoking.
- Filters on listing type and on a rent range.
- Plain HTTP with datacenter proxies. No browser, so runs are fast and cheap.

### How to scrape Kamernet data

1. Open the actor and leave the prefill (Utrecht) or enter your own cities.
2. Set `maxResults` to the number of listings you want.
3. Optionally choose listing types and a rent range.
4. Start the run and download the dataset as JSON, CSV or Excel.

A city is written the way it appears in Kamernet addresses: `amsterdam`, `utrecht`, `den-haag`, `rotterdam`. Leave `cities` empty to read the whole of the Netherlands, which is about 1,500 listings at any time.

### Input

| Field | Description |
|---|---|
| `cities` | City names as written in Kamernet addresses. Empty reads the whole of the Netherlands. |
| `listingTypes` | `rooms`, `apartments`, `studios`. Empty reads all three together. |
| `minRent`, `maxRent` | Monthly rent range in euro. Applied after each page is read. |
| `includeDetails` | Opens every listing page for the title, description, postal code, coordinates, deposit and house rules. On by default. |
| `maxResults` | Maximum number of rows. Default 50. |
| `proxyConfiguration` | Apify Proxy settings. Datacenter addresses work. |

When several cities and several listing types are given, the actor reads every combination in order until `maxResults` is reached. A listing that appears in more than one combination is saved once.

### What you get back

| Field | Description |
|---|---|
| `listingId` | Kamernet listing number |
| `title` | Title written by the landlord |
| `url` | Listing page address |
| `listingType` | `room`, `apartment` or `studio` |
| `rent`, `currency` | Monthly rent and EUR |
| `utilitiesIncluded` | True when gas, water and electricity are in the rent |
| `deposit`, `agencyFee` | Deposit and agency fee, when given |
| `surfaceArea` | Size in square metres |
| `rooms`, `bedrooms` | Number of rooms and bedrooms, when given |
| `furnishing` | `unfurnished`, `upholstered` or `furnished` |
| `street`, `houseNumber`, `postalCode`, `city`, `citySlug` | Address of the place |
| `latitude`, `longitude` | Coordinates of the postal code |
| `availableFrom`, `availableUntil` | Rental period. `availableUntil` is empty when the rental has no end date |
| `description` | Full listing text, in Dutch |
| `kitchen`, `bathroom`, `toilet`, `livingRoom` | `shared` or `private`, when given |
| `petsAllowed`, `smokingAllowed` | House rules |
| `maxTenants` | Number of people the place suits |
| `isStudentHouse` | True for a room in a student house |
| `imageUrl`, `imageUrls`, `imageCount` | Main image, all images and the number of images |
| `isNew`, `isTopAdvert` | Listing marked new, paid top placement |
| `postedAt` | Date and time the listing was published |
| `scrapedAt`, `country` | Time of the scrape and `NL` |

Landlord names and ids are not saved.

### Example output

```json
{
  "listingId": "2418142",
  "title": "Ruime kamer in Overvecht",
  "url": "https://kamernet.nl/huren/kamer-utrecht/arnodreef/kamer-2418142",
  "listingType": "room",
  "rent": 700,
  "currency": "EUR",
  "utilitiesIncluded": true,
  "deposit": 550,
  "surfaceArea": 15,
  "furnishing": "unfurnished",
  "street": "Arnodreef",
  "houseNumber": "21",
  "postalCode": "3561GJ",
  "city": "Utrecht",
  "latitude": 52.111983,
  "longitude": 5.122448,
  "availableFrom": "2026-12-01T00:00:00",
  "availableUntil": "2027-04-30T00:00:00",
  "kitchen": "shared",
  "bathroom": "shared",
  "petsAllowed": false,
  "smokingAllowed": false,
  "maxTenants": 1,
  "country": "NL"
}
```

### Use cases

- Track room and apartment rents per city and per postal code.
- Watch new listings every day with a schedule.
- Compare furnished and unfurnished rents in student cities.
- Map rental supply with the coordinates.
- Feed a housing comparison site or a relocation service with Dutch listings.

### Cost and speed

Each listing is one result row and is billed as one result. The price per result is on the actor page. With `includeDetails` on, every listing needs its own page request, so 100 listings take about one minute. With it off, 17 listings come from each page request and a full run of the Netherlands takes a few minutes. The usage cost of a run only settles after the run has finished successfully.

### Notes and limits

- The actor reads the listing pages of the site. The search endpoints that robots.txt closes to automated access are not used.
- A city page also lists listings from nearby towns, so a search for Amsterdam includes places such as Hilversum or Diemen.
- Listings are saved once, even when the same listing appears under several cities or listing types.
- The rent filter is applied after a page is read, so a narrow range on a large area reads many pages.
- `availableUntil`, `deposit`, `agencyFee`, `rooms` and `bedrooms` are only filled when the landlord gives them.
- `kitchen`, `bathroom`, `toilet` and `livingRoom` are only filled when the listing states whether they are shared or private.
- Descriptions are written by landlords, mostly in Dutch, sometimes in English.
- A city with no listings ends the run as SUCCEEDED with no rows.
- The actor reads publicly visible data only. It does not log in.
- You are responsible for how you use the data. Check the site's terms and the rules that apply to your use case.

### Frequently asked questions

#### How do I read one city?

Add the city to `cities`, for example `amsterdam`. Cities with a space in the name are written with a hyphen, for example `den-haag`.

#### How do I read only rooms?

Set `listingTypes` to `rooms`. Use `studios` or `apartments` for the other two kinds.

#### Do I get the full description?

Yes, with `includeDetails` on, which is the default. Switch it off for a faster run with the basic fields only.

#### What does furnishing mean?

`unfurnished` is a bare place, `upholstered` has floors and window covering, and `furnished` comes with furniture.

#### Are landlord contact details included?

No. The actor saves the listing and its address, not the landlord's name or id.

#### How often can I run it?

As often as you like. A scheduled run with a small `maxResults` gives a feed of the newest listings.

### Related scrapers

- [Funda Scraper](https://apify.com/studio-amba/funda-scraper) for Dutch property for sale and rent
- [Pararius Scraper](https://apify.com/studio-amba/pararius-scraper) for Dutch rental homes

# Actor input Schema

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

City names as written in Kamernet addresses, for example amsterdam, utrecht or den-haag. Leave empty to read the whole of the Netherlands.

## `listingTypes` (type: `array`):

Which kinds of places to read: rooms, apartments or studios. Leave empty to read all three together.

## `minRent` (type: `integer`):

Only listings with a monthly rent at or above this amount, in euro. Applied after reading each page.

## `maxRent` (type: `integer`):

Only listings with a monthly rent at or below this amount, in euro. Applied after reading each page.

## `includeDetails` (type: `boolean`):

Open every listing page to add the title, description, postal code, coordinates, deposit and house rules. On by default. Switch off for a faster run with the basic fields only.

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

Maximum number of rows (one row per listing).

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

Apify Proxy settings. Datacenter addresses by default.

## Actor input object example

```json
{
  "cities": [
    "utrecht"
  ],
  "includeDetails": true,
  "maxResults": 20,
  "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 = {
    "cities": [
        "utrecht"
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/kamernet-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/3GvHiM5GbojOStvZW/builds/etGds0tGC1ubdaJm3/openapi.json
