# Nestpick Scraper (`crawlerbros/nestpick-scraper`) Actor

Scrape furnished mid- to long-term rental listings from Nestpick - rooms, studios and apartments across 3000+ cities, aggregated from Spotahome, Blueground, HousingAnywhere and other providers. Filter by price, size, rooms; enrich listings with their external booking URL.

- **URL**: https://apify.com/crawlerbros/nestpick-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Nestpick Scraper

Scrape furnished mid- to long-term rental listings from [Nestpick](https://www.nestpick.com) — rooms, studios and apartments across 3000+ cities worldwide, aggregated from partner providers such as Spotahome, Blueground and HousingAnywhere. Search any city with price, size, rooms, provider and verified-badge filters, or enrich specific listings with their true external booking URL. No login, no cookies, no paid proxy required.

### What this actor does

- **Two modes:** `search` (by city) and `listingDetails` (by listing ID or URL)
- **Global coverage** — any city Nestpick lists; just type a city name (accents and spaces are handled automatically)
- **Rich filters** — property type, EUR-normalized price range, min rooms, min size, verified-only, provider name, required amenity (24 options, e.g. balcony, pets allowed, parking)
- **Sorting** — price ascending/descending, size, room count, or the site's own relevance order
- **Enrichment mode** — resolve a listing's real external booking URL (e.g. the actual Spotahome/Blueground page) plus provider codes and full amenity list
- **Empty fields are omitted** — every record only contains data that was actually found

### Output per listing

**Search mode:**

- `listingId`, `title`, `address`
- `propertyType` (`room` / `studio` / `apartment` / `residence_hall`)
- `providerName`, `providerCode`, `providerLogoUrl`
- `price`, `priceCurrency` (listing's local currency), `priceEur` (Nestpick's own cross-currency normalized price)
- `sizeSqm`, `sizeSqft`, `rooms`
- `availableFrom`, `minStayMonths`
- `amenities[]`, `verified`
- `imageUrls[]`, `mainImageUrl`
- `sourceUrl`, `city`, `searchCategory`
- `recordType: "listing"`, `scrapedAt`

**Listing details mode** (adds/replaces):

- `providerPropertyCode`, `cityCode`
- `externalListingUrl` — the actual partner-site URL the listing redirects to
- `recordType: "listingDetail"`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `listingDetails` |
| `city` | string | `Berlin` | City name (mode=search); any spelling/casing/accents accepted |
| `category` | string | `rooms` | `rooms` or `apartments` listing category |
| `propertyType` | string | `any` | Filter to `room` / `studio` / `apartment` / `residence_hall` |
| `minPriceEur` / `maxPriceEur` | int | – | Price range filter, EUR-normalized (works across any local currency) |
| `minRooms` | int | – | Drop listings with fewer rooms |
| `minSqm` | int | – | Drop listings smaller than this size |
| `verifiedOnly` | bool | `false` | Only keep Nestpick-verified listings |
| `providerName` | string | – | Keep only listings whose provider name/code contains this text |
| `amenity` | string | `any` | Keep only listings that list this amenity (24 options, e.g. `balcony`, `pets`, `pool`) |
| `sortBy` | string | `relevance` | `relevance` / `priceAsc` / `priceDesc` / `sqmDesc` / `roomsDesc` |
| `listingIds` | array | – | Numeric listing IDs (mode=listingDetails) |
| `listingUrls` | array | – | Full `nestpick.com/pick/{id}/` URLs (mode=listingDetails) |
| `maxItems` | int | `30` | Hard cap on emitted records (1–500) |

#### Example: verified studios in Seoul under €2000

```json
{
  "mode": "search",
  "city": "Seoul",
  "category": "apartments",
  "propertyType": "studio",
  "maxPriceEur": 2000,
  "verifiedOnly": true,
  "sortBy": "priceAsc",
  "maxItems": 50
}
```

#### Example: resolve external booking URLs for specific listings

```json
{
  "mode": "listingDetails",
  "listingIds": ["21514575", "20393877"]
}
```

### Use cases

- **Relocation & corporate housing** — compare furnished rentals across cities before assigning a budget
- **Market research** — track average rents, sizes and provider mix by city
- **Aggregator monitoring** — check which partner providers (Spotahome, Blueground, etc.) are active in a market and at what price point
- **Lead generation** — resolve the real booking page behind a Nestpick listing for outreach or comparison tools

### Notes

- Prices are shown in each listing's local currency (`price` + `priceCurrency`). Because currencies vary city to city, use `priceEur` / `minPriceEur` / `maxPriceEur` for consistent cross-market filtering — this is the same EUR-normalized value Nestpick uses internally for sorting.
- Not every city has both a `rooms` and an `apartments` category; if a combination doesn't exist the run finishes cleanly with a status message instead of erroring.
- Sorting is applied within the batch of listings actually fetched for the run (bounded by `maxItems`), not across Nestpick's entire inventory for that city.

### FAQ

**Does this require login or cookies?**
No. All data comes from Nestpick's public search pages.

**Why is `priceEur` sometimes different from `price`?**
`price` is the listing's real price in its local currency (e.g. Korean Won). `priceEur` is Nestpick's own EUR-normalized equivalent, useful for comparing or filtering listings across different currencies.

**Can I search by neighborhood or postcode?**
Not currently — search is by city. Use `providerName` and the price/size/rooms filters to narrow results within a city.

**Are all fields always present?**
No — only fields with real data are included. A listing without a published size, for example, simply omits `sizeSqm`.

**Can I filter by "Corporate Housing"?**
Not currently. Nestpick's site tags Corporate Housing as a separate attribute from `propertyType` (room/studio/apartment/residence\_hall) via its client-side JS filter UI, which isn't exposed through a reliable server-side URL parameter, so this actor doesn't support filtering on it. `propertyType` and `amenity` cover every filter that reliably works via a plain HTTP GET.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

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

City name, e.g. `Berlin`, `London`, `New York`, `Tokyo`, `Sao Paulo`. Nestpick covers 3000+ cities worldwide — any city name accepted; it is normalized to Nestpick's URL slug automatically.

## `category` (type: `string`):

Which listing category page to search. `Rooms` covers single rooms; `Apartments` covers studios and full apartments. Not every city has both categories available.

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

Restrict results to one property type. `Any` keeps every type returned by the chosen category.

## `minPriceEur` (type: `integer`):

Drop listings priced below this amount. Nestpick shows prices in each city's local currency, so filtering uses the EUR-normalized price Nestpick itself computes for cross-currency sorting (see `priceEur` output field).

## `maxPriceEur` (type: `integer`):

Drop listings priced above this amount (EUR-normalized, see `minPriceEur`).

## `minRooms` (type: `integer`):

Drop listings with fewer rooms than this.

## `minSqm` (type: `integer`):

Drop listings smaller than this size in square meters. Listings without a published size always pass through.

## `verifiedOnly` (type: `boolean`):

Only keep listings carrying Nestpick's "Verified" badge.

## `providerName` (type: `string`):

Keep only listings from a partner provider whose name/code contains this text (case-insensitive), e.g. `Spotahome`, `Blueground`, `HousingAnywhere`.

## `amenity` (type: `string`):

Keep only listings that list this amenity (matches Nestpick's own amenity taxonomy, same as the `amenities` output field).

## `sortBy` (type: `string`):

How to order results within the fetched batch. `Relevance` keeps Nestpick's own result order.

## `listingIds` (type: `array`):

Numeric Nestpick listing IDs, e.g. `21514575`.

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

Full Nestpick listing URLs, e.g. `https://www.nestpick.com/pick/21514575/`.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "city": "Berlin",
  "category": "rooms",
  "propertyType": "any",
  "verifiedOnly": false,
  "amenity": "any",
  "sortBy": "relevance",
  "listingIds": [],
  "listingUrls": [],
  "maxItems": 30
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped Nestpick listings.

# 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 = {
    "mode": "search",
    "city": "Berlin",
    "category": "rooms",
    "propertyType": "any",
    "verifiedOnly": false,
    "amenity": "any",
    "sortBy": "relevance",
    "listingIds": [],
    "listingUrls": [],
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/nestpick-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 = {
    "mode": "search",
    "city": "Berlin",
    "category": "rooms",
    "propertyType": "any",
    "verifiedOnly": False,
    "amenity": "any",
    "sortBy": "relevance",
    "listingIds": [],
    "listingUrls": [],
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/nestpick-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 '{
  "mode": "search",
  "city": "Berlin",
  "category": "rooms",
  "propertyType": "any",
  "verifiedOnly": false,
  "amenity": "any",
  "sortBy": "relevance",
  "listingIds": [],
  "listingUrls": [],
  "maxItems": 30
}' |
apify call crawlerbros/nestpick-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/nestpick-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/8jmytNfRvwaT9wEfd/builds/8Z4tZvcsrTx5WbtbX/openapi.json