# VRBO Scraper - Vacation Rentals, Prices & Reviews (`khadinakbar/vrbo-scraper`) Actor

Scrape VRBO vacation rentals by destination or URL — listings, full property detail, and guest reviews. Akamai-hardened, MCP-ready.

- **URL**: https://apify.com/khadinakbar/vrbo-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Travel, Real estate, MCP servers
- **Stats:** 7 total users, 2 monthly users, 93.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 listing or property scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## VRBO Scraper - Vacation Rentals, Prices & Reviews

VRBO Scraper is an Apify Actor for travel and real-estate workflows that start with a destination, a VRBO search URL, or a VRBO property URL or ID. It accepts one search location or one or more exact VRBO URLs, and each dataset record represents one listing, one property, or one review. The useful fields include names, property type, bedrooms, bathrooms, sleeps, ratings, review counts, price fields, city, region, country, coordinates, image URL, amenities, host, description, review metadata, source URL, and scraped timestamp. This Actor runs on Apify, is usable through Apify MCP, and returns structured records that are ready for filtering, joining, and downstream analysis.

### Best fit and connected workflows

This Actor fits workflows that begin with a VRBO market question and end with structured records you can sort, filter, join, and pass into downstream analysis.

It is a strong fit for:

- destination searches that return VRBO listing cards,
- direct property scraping from known VRBO URLs or property IDs,
- review collection linked back to each property by `propertyId`,
- stay-specific pricing checks using `checkIn` and `checkOut`,
- AI-agent workflows through Apify MCP,
- spreadsheet, BI, warehouse, and custom-script pipelines.

A practical routing pattern is:

1. Search a destination with `destination` or a search URL in `startUrls`.
   a bounded number of Review the listing cards and shortlist relevant properties.
   a bounded number of Run the selected property URLs again for full detail and guest reviews.
2. Use `sourceUrl`, `propertyId`, and `scrapedAt` for traceability.

### Practical scenario

A rental analyst starts with `destination: "Lake Tahoe"` and wants a short market scan. The run returns listing records with `name`, `propertyType`, `bedrooms`, `bathrooms`, `sleeps`, `rating`, `reviewCount`, and price fields. She uses `rating` and `reviewCount` to narrow the set, then opens a few property URLs in a second run to get `amenities`, `host`, `description`, exact geo fields, and guest reviews. Her next action is to compare the selected properties side by side and share the review-linked dataset with her team.

### Input fields

| Field | Type | Description |
|---|---|---|
| `destination` | string | Search VRBO by place name, city, region, or area. Example: `Lake Tahoe`. |
| `startUrls` | array | Provide exact VRBO search URLs, property URLs, or property IDs. Mixed lists are accepted. |
| `checkIn` | string | Optional stay start date in `YYYY-MM-DD` format for availability-aware pricing. |
| `checkOut` | string | Optional stay end date in `YYYY-MM-DD` format paired with `checkIn`. |
| `adults` | integer | Adult guest count used for search filtering and pricing. Default: 2. |
| `maxResults` | integer | Hard cap on listing or property records returned across all inputs. Default: 50. |
| `enrichDetails` | boolean | Open each search result on its property page for full detail and reviews. Default: false. |
| `includeReviews` | boolean | Return guest reviews as separate review records. Default: true. |
| `maxReviewsPerProperty` | integer | Upper bound on reviews fetched per property. Default: 20. |
| `debugDumpToKv` | boolean | Save raw extraction artifacts to the key-value store for troubleshooting. |
| `proxyConfiguration` | object | Proxy settings for the run. Residential proxy is the default. |

#### Focused JSON example

```json
{
  "destination": "Destin, Florida, United States of America",
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-08",
  "adults": 4,
  "maxResults": 25,
  "enrichDetails": true,
  "includeReviews": true,
  "maxReviewsPerProperty": 10
}
```

### Output fields

Each dataset item is a flat JSON record. `recordType` identifies whether the record is a `listing`, `property`, or `review`. Review records link back to the property through `propertyId`.

| Field | Type | Description |
|---|---|---|
| `recordType` | string | Record type: `listing`, `property`, or `review`. |
| `id` | string | VRBO listing or property ID. |
| `url` | string | Canonical VRBO URL for the record. |
| `name` | string | Listing or property headline. |
| `propertyType` | string | Property category such as condo, house, or cabin. |
| `bedrooms` | integer | Bedroom count. |
| `bathrooms` | number | Bathroom count. |
| `sleeps` | integer | Stated guest capacity. |
| `rating` | number | Average guest rating for listing or property, or the review rating. |
| `reviewCount` | integer | Review count for the listing or property. |
| `priceLabel` | string | Formatted price as shown on VRBO. |
| `pricePerNight` | number | Nightly price in numeric form. |
| `currency` | string | Currency code. |
| `city` | string | City on the record. |
| `region` | string | Region or state on the record. |
| `country` | string | Country on the record. |
| `postalCode` | string | Postal code when present. |
| `latitude` | number | Latitude when present. |
| `longitude` | number | Longitude when present. |
| `imageUrl` | string | Primary image URL. |
| `amenities` | array | Amenity names from the property record. |
| `host` | string | Host or host label. |
| `description` | string | Property description. |
| `reviewId` | string | Review ID on review records. |
| `title` | string | Review title on review records. |
| `text` | string | Review body on review records. |
| `reviewer` | string | Review author or reviewer name. |
| `stayDate` | string | Stay date on review records. |
| `publishedDate` | string | Review publish date. |
| `propertyId` | string | Foreign key linking a review to its property. |
| `propertyUrl` | string | Property URL linked to the review. |
| `sourceUrl` | string | URL the record was scraped from. |
| `scrapedAt` | string | ISO-8601 timestamp of extraction. |

#### Illustrative JSON record

```json
{
  "recordType": "property",
  "id": "1234567",
  "url": "https://www.vrbo.com/1234567",
  "name": "Beachfront Condo with Gulf Views",
  "propertyType": "Condo",
  "bedrooms": 2,
  "bathrooms": 2,
  "sleeps": 6,
  "rating": 4.8,
  "reviewCount": 137,
  "priceLabel": "$245 / night",
  "pricePerNight": 245,
  "currency": "USD",
  "city": "Destin",
  "region": "Florida",
  "country": "United States",
  "postalCode": "32541",
  "latitude": 30.3935,
  "longitude": -86.4958,
  "imageUrl": "https://example.com/image.jpg",
  "amenities": ["Pool", "Wi-Fi", "Beach access"],
  "host": "Gulf Coast Rentals",
  "description": "Oceanfront condo with balcony views.",
  "sourceUrl": "https://www.vrbo.com/1234567",
  "scrapedAt": "2026-06-14T10:00:00.000Z"
}
```

### How it works

This Actor accepts either a destination search or exact VRBO URLs and auto-detects whether each URL points to a search result page or a property page. Search mode collects vacation-rental listings and auto-paginates until it reaches `maxResults`. When `enrichDetails` is enabled, each search result is opened on its property page to collect full detail fields such as description, amenities, host, exact geo, and reviews. Direct property URLs always return full detail.

The live implementation uses a stealth Playwright Chromium flow with residential or mobile proxy support for Akamai-protected pages. If every browser proxy is blocked, a bounded public-index fallback accepts only genuine canonical VRBO property pages returned by SerpAPI; it rejects search, editorial, and third-party pages. The contract also includes a diagnostic mode that can save raw page data and intercepted payloads to the key-value store for troubleshooting.

### Pricing

This Actor uses Pay per event pricing on the Apify platform, and Apify platform usage is billed separately. Open the live Pricing tab on the Actor page for the current configuration.

A simple event-count example: if a run returns one hundred listing or property records and twenty guest reviews, the billed work is one actor start event, one hundred listing-or-property events, and twenty review events. You can reduce record count with `maxResults`, and you can bound review collection with `maxReviewsPerProperty`.

### Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. The precise tool target is the Actor identity `khadinakbar/vrbo-scraper`.

Use it when an agent needs VRBO search results, property detail, or review records in a structured dataset.

> Scrape VRBO for Lake Tahoe with up to 20 results. Return listing cards first, then enrich selected property URLs for full detail and guest reviews. Keep the output keyed by propertyId and include sourceUrl for provenance.

Output interpretation:

- `listing` records support destination scans and shortlist building.
- `property` records contain the expanded property detail view.
- `review` records are linked to a property through `propertyId`.

Provenance and scope:

- `sourceUrl` captures the page each record came from.
- `scrapedAt` marks extraction time in ISO-8601 format.
- `propertyUrl` and `propertyId` connect review records back to the property.
- `maxResults` caps listing and property records across all inputs.
- Reviews are counted separately from the record cap.
- `maxReviewsPerProperty` bounds per-property review collection.

### Apify API example

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  destination: 'Destin, Florida, United States of America',
  maxResults: 10,
  enrichDetails: true,
  includeReviews: true,
  maxReviewsPerProperty: 5,
};

const run = await client.actor('khadinakbar/vrbo-scraper').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### Best results and outcome guidance

Use `destination` for broad discovery and `startUrls` when you already have a VRBO page to target. Use `checkIn` and `checkOut` together when you want stay-specific nightly prices. Keep `maxResults` aligned with the market slice you want to review. Turn on `enrichDetails` when you need amenities, host, and exact location fields for each search result. Use `includeReviews` and `maxReviewsPerProperty` when review records are part of your analysis.

### Design note

I found that the dataset contract separates `listing`, `property`, and `review` records through `recordType`, and that review records are linked back to properties with `propertyId`. That makes it practical to process search results and review records in the same dataset while keeping provenance clear.

### FAQ

#### When should I use `destination` instead of `startUrls`?

Use `destination` when you want VRBO to search by place name. Use `startUrls` when you already have a VRBO search page, a property page, or a raw property ID.

#### Can I mix search URLs and property URLs in `startUrls`?

Yes. The input contract auto-detects search versus property mode for each URL, so mixed lists are accepted.

#### How do I get full property fields from search results?

Set `enrichDetails` to true. Each search result is then opened on its own property page to collect full detail fields and reviews.

#### How are reviews connected to properties?

Review records include `propertyId`, and they also include `propertyUrl` when available. That lets you join reviews to the corresponding property record.

#### Where should I check current pricing?

Open the live Pricing tab on the Actor page. This README explains the Pay per event structure, while the live tab shows the current pricing configuration.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow.

### Responsible use

Use this Actor in ways that respect VRBO, applicable laws, and data-protection requirements. Keep your automation aligned with the data you need, and review the live pricing and proxy settings before running large jobs.

# Actor input Schema

## `destination` (type: `string`):

Use this to search VRBO by place: a free-text city, region, or area such as 'Destin, Florida, United States of America' or 'Lake Tahoe'. The actor opens VRBO search, collects vacation-rental listings, and auto-paginates up to Max results. Leave empty if you instead pass property or search URLs in Start URLs. NOT a property URL — to scrape one rental use Start URLs.

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

Use this for exact VRBO URLs instead of a text search. Accepts VRBO search-result URLs (https://www.vrbo.com/search?destination=...) and individual property URLs or IDs (https://www.vrbo.com/1234567 or just 1234567). Each URL's mode (search vs property) is auto-detected. Mixed lists are fine; non-VRBO URLs are skipped with a warning.

## `checkIn` (type: `string`):

Optional stay start date in YYYY-MM-DD format (e.g. '2026-08-01') used to fetch availability-aware nightly prices in search mode. Leave empty for undated 'from' prices. Must be earlier than Check-out. NOT a duration — pass an explicit calendar date.

## `checkOut` (type: `string`):

Optional stay end date in YYYY-MM-DD format (e.g. '2026-08-08'), paired with Check-in to price a specific stay window. Leave empty for undated prices. Must be after Check-in or both dates are ignored. NOT the number of nights — pass a calendar date.

## `adults` (type: `integer`):

Number of adult guests used to filter and price search results (e.g. 4). Defaults to 2. Range 1–16. Ignored for direct property URLs.

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

Hard cap on how many listing/property records to return across all inputs (e.g. 100). Defaults to 50. Pagination stops once this is reached, so it also bounds cost. Reviews do not count against this cap.

## `enrichDetails` (type: `boolean`):

When on, every search result is opened on its own property page to collect full fields (description, amenities, host, exact geo) and reviews. When off (default), search returns faster, cheaper listing cards only. Direct property URLs always return full detail regardless of this flag. Turning this on increases run time and cost.

## `includeReviews` (type: `boolean`):

When on (default), property pages also return guest reviews as separate review records linked by propertyId. Applies to direct property URLs and, when Visit each listing is on, to search results too. Turn off to skip reviews entirely. Each review is billed separately — see pricing.

## `maxReviewsPerProperty` (type: `integer`):

Upper bound on reviews fetched per property (e.g. 20). Defaults to 20, max 200. Set 0 to disable reviews even if Include reviews is on. Caps per-property review cost.

## `debugDumpToKv` (type: `boolean`):

Diagnostic only. When on, saves raw HTML, script summaries, and intercepted API payloads to the key-value store (DEBUG-\* keys) to troubleshoot extraction. Leave off for normal runs. Does not change billing.

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

Proxy settings. VRBO is protected by Akamai, so residential proxies are strongly recommended and on by default (US). Datacenter proxies will be blocked. Leave default unless you have a reason to change country or group.

## Actor input object example

```json
{
  "destination": "Lake Tahoe",
  "startUrls": [
    {
      "url": "https://www.vrbo.com/1234567"
    }
  ],
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-08",
  "adults": 2,
  "maxResults": 1,
  "enrichDetails": false,
  "includeReviews": true,
  "maxReviewsPerProperty": 20,
  "debugDumpToKv": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "destination": "Destin, Florida, United States of America",
    "startUrls": [],
    "maxResults": 1,
    "includeReviews": false,
    "maxReviewsPerProperty": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/vrbo-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 = {
    "destination": "Destin, Florida, United States of America",
    "startUrls": [],
    "maxResults": 1,
    "includeReviews": False,
    "maxReviewsPerProperty": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/vrbo-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 '{
  "destination": "Destin, Florida, United States of America",
  "startUrls": [],
  "maxResults": 1,
  "includeReviews": false,
  "maxReviewsPerProperty": 0
}' |
apify call khadinakbar/vrbo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/vrbo-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/7jqemqOUPokzo4OCq/builds/2UxuL29jVvLOQoiR2/openapi.json