# Despegar Reviews Scraper \[Only $1.5/1K💰] | Hotels | Scores (`ahmed_jasarevic/despegar-reviews-scraper`) Actor

Scrape complete hotel review sets from any Despegar country site — Mexico, Argentina, Colombia, Chile and more — with reviewer, traveller type, month, score and liked/disliked comments, plus six category scores and AI summaries. No browser, no API key, $0.0015 per review.

- **URL**: https://apify.com/ahmed_jasarevic/despegar-reviews-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 $1.40 / 1,000 hotel reviews

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

## Despegar Reviews Scraper

**Extract complete hotel review sets from any Despegar country site — Mexico, Argentina, Colombia, Chile, Peru, the US and more — with reviewer, traveller type, month, score and separated liked/disliked comments, plus six category scores and Despegar's AI review summary.** No browser, no API keys: plain HTTP against the same endpoints Despegar's pages serve to anonymous visitors, at **$0.0015 per review** — the cheapest per-review price verified on the Apify Store.

Built for hospitality marketers, hotel owners, OTAs benchmarking competitors, travel market researchers and voice-of-customer analysts.

### Main Use Cases

- **Hotel reputation monitoring** — track score, category scores and review sentiment per property over time with scheduled runs
- **Guest reviews dataset** — build a structured review database of Latin American hotels for analysis or model training
- **Hotel competitor benchmarking** — compare aggregate and category scores (service, staff, location, internet, cleaning, price/quality) across a competitive set
- **Voice-of-customer analysis** — positive and negative comments arrive already separated, so sentiment/feedback models don't have to infer polarity from one blob of text
- **Hospitality market research** — review volume, country of origin, traveller type and language mix per market
- **Travel review data for OTAs** — enrich partner feeds or power review widgets with structured guest feedback

### How It Works — No Browser, No API Keys

The actor sends plain HTTP requests to the same review endpoints Despegar's own pages call when an anonymous visitor opens a hotel. Each hotel page URL yields its review stream plus a summary record — no browser, no cookies, no login. A 625-review hotel costs about 13 HTTP requests and finishes in seconds — roughly **100× cheaper than a headless-browser approach**.

**The one trick that matters: complete coverage.** Despegar's own unfiltered review query silently omits roughly a third of a hotel's reviews. The actor therefore runs **every traveller-type query** (`all`, `couple`, `family`, `friends`, `singles`) and merges the results — turning a 399-review hotel into 625, a 97-review hotel into 201. No other store actor does this merge.

**Residential proxies are required and pinned to the market.** Despegar returns HTTP 403 to every datacenter IP. The actor defaults to `RESIDENTIAL` proxy, derives the proxy country from each start URL's domain (AR for `despegar.com.ar`, MX for `despegar.com.mx`, …) and pins it for the whole run — a request that reaches a market through a foreign exit IP gets rejected. Split mixed-country inputs into one run per country, or set `proxyCountry` yourself.

### Build a Latin American Hotel Review Database Without a Reviews API

Despegar offers no public reviews API. The three viable routes for guest review data in LatAm are: (1) this actor's HTTP approach — cheapest and fastest; (2) browser-based scraping — 100× the compute; (3) manual collection — not scalable. The merge behaviour above is what makes the dataset complete rather than a sample: the unfiltered query alone is missing roughly one review in three, and per-review pricing means the merge costs the same per review as an incomplete run.

The **Output** tab splits the run into two datasets — `reviews` (one row per guest review, de-duplicated by Despegar review id) and `hotels` (one row per hotel with aggregate + category scores and the AI summary) — so absence of a review list never hides the reputation summary, and vice versa.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | **Yes** | — | Despegar hotel page URLs; the country domain picks language/country (mix `.com.ar`, `.com.mx`, `us.despegar.com`, … freely) |
| `maxHotels` | integer | No | `20` | Maximum hotels to scrape; extra URLs dropped once reached |
| `maxReviewsPerHotel` | integer | No | `0` | Cap per hotel; `0` = every review the endpoint returns. Small caps bias the sample (see FAQ) |
| `cutoffDate` | string | No | `""` | Keep only reviews from this month onwards, `YYYY-MM`. Despegar publishes month granularity only |
| `locale` | string | No | `""` | Force the request locale, e.g. `es-MX`, `pt-BR`. Empty = derive from each URL's domain (recommended) |
| `travelerType` | enum | No | `all` | `all` = run every traveller-type query and merge (complete coverage). Single type = cheaper, targeted segment |
| `reviewPageSize` | integer | No | `100` | Reviews per request; the endpoint caps at 100 |
| `includeHotelSummary` | boolean | No | `true` | Emit one `hotelSummary` item per hotel (score, six category scores, review count, AI summary) |
| `fetchHotelPages` | boolean | No | `true` | Fetch each hotel page to capture the hotel name. `false` saves one request per hotel, `hotelName` stays empty |
| `maxRequestsPerCrawl` | integer | No | `0` | Safety cap on total requests; `0` = no limit |
| `maxConcurrency` | integer | No | `10` | Parallel requests, 1–50 |
| `proxyConfiguration` | object | No | RESIDENTIAL | Required in the cloud — datacenter IPs get 403 |
| `proxyCountry` | string | No | from URL | Pin the proxy to one ISO country (`AR`, `MX`, …); empty derives it per hotel |

### Output — Guest Review and Hotel Summary Records

**`reviews` dataset** (one row per review):

| Field | Description |
|---|---|
| `hotelName`, `hotelId`, `hotelUrl` | The hotel the review belongs to (name empty when `fetchHotelPages: false`) |
| `reviewerName`, `reviewerCountry`, `reviewerCountryCode` | Reviewer identity — a first name on ~70% of reviews, a country on ~60%; `null` otherwise |
| `travelerType`, `travelerTypeLabel` | Stable type (`couple`, `family`, `friends`, `singles`, …) + localized label |
| `language`, `locale` | Language of the text and the locale used for the request |
| `date`, `dateMonth`, `dateIso` | Review date: raw value (`Marzo 2024`), sortable `YYYY-MM`, and first day of month for charting |
| `rating`, `ratingLabel` | 0–10 score, numeric and as displayed |
| `positiveComment`, `negativeComment` | What the guest liked / disliked, already separated |
| `usefulCount` | How many readers found it helpful |
| `provider`, `providerLabel` | `DESPEGAR` / guest-verified label |
| `scrapedAt` | ISO timestamp of the run |

**`hotels` dataset** (one row per hotel): `hotelName`, `hotelUrl`, `score`, `generalRating`, `reviewCount`, `categories` (six category scores), `generatedReview` (Despegar's AI summary).

### Example Input

```json
{
    "startUrls": [
        { "url": "https://www.us.despegar.com/hotels/h-352691/bluebay-grand-esmeralda-all-inclusive-riviera+maya" },
        { "url": "https://www.despegar.com.ar/hotels/h-2867398/nickelodeon-hotels-resorts-riviera-maya-by-karisma" }
    ],
    "maxHotels": 2,
    "cutoffDate": "2025-01",
    "travelerType": "all"
}
```

`startUrls` expects objects with a `url` field (what the Console form writes for you). Mix country domains in one input — each URL decides its own language and market.

### Example Output — Review Record (trimmed)

```json
{
    "type": "review",
    "hotelId": "2867398",
    "hotelName": "Nickelodeon Hotels & Resorts Riviera Maya , By Karisma",
    "hotelUrl": "https://www.despegar.com.ar/hotels/h-2867398/...",
    "locale": "es-AR",
    "reviewerName": "Ana",
    "reviewerCountry": "Indonesia",
    "travelerType": "family",
    "language": "es",
    "dateMonth": "2024-03",
    "rating": 7.1,
    "positiveComment": "Las instalaciones son increíbles, los juegos para los niños son muy buenos.",
    "negativeComment": "Es un hotel \"todo incluido\" horrible, la comida es malísima.",
    "usefulCount": 18,
    "scrapedAt": "2026-09-26T18:24:02.546Z"
}
```

### Hotel Review Monitoring at $0.0015 Per Review

**One price per review, one price per hotel summary:** the actor bills via Apify's pay-per-event model — **$0.0015 per review**, **$0.00009 per hotel summary**, plus Apify's standard **$0.00005 actor start**. No subscriptions, no per-GB charges, no browser minutes. `travelerType: all` (the default) costs the same per review as an unfiltered run — completeness is free. The cheapest competitor verified on the Store charges $0.00433 per review, so a 1,000-review monitoring batch costs **$1.50 here vs ~$4.33 there**. Free Apify accounts see a preview; paid plans run to your caps.

### Integrations & Automation

- **API** — run and fetch via the Apify REST API, or call it from AI agents through the Apify MCP server
- **Scheduling** — recurring runs keep a hotel watchlist fresh; compare `dateMonth` across runs for month-over-month tracking
- **Webhooks** — push new reviews or score changes to your app or dashboard
- **Export** — JSON, CSV, Excel, XML, HTML

**Recommended schedule:** monthly for long-term reputation trend lines (review volumes are month-granular); weekly during peak seasons or after promotional pushes.

### Related Actors

- [Despegar Reviews Scraper](https://apify.com/knagymate/despegar-reviews-scraper) — `knagymate/despegar-reviews-scraper` — $0.002 start + $0.00433/review; Despegar + Decolar reviews
- [Despegar & Decolar Reviews Scraper — AI Summary & Filters](https://apify.com/korado_labs/despegar-reviews-scraper) — `korado_labs/despegar-reviews-scraper` — review extraction with AI summary
- [Despegar Reviews Scraper](https://apify.com/haketa/despegar-reviews-scraper) — `haketa/despegar-reviews-scraper` — Despegar reviews
- [Hotel Reputation Checker](https://apify.com/kestrel/hotel-reputation-checker) — `kestrel/hotel-reputation-checker` — free multi-source hotel reputation data

This actor differentiates on price per review and on **complete review sets**: the traveller-type merge recovers the ~1/3 of reviews that unfiltered queries omit, at the same per-review price.

### FAQ

#### Why use this actor instead of the official Despegar API?

Despegar does not offer a public reviews API. The actor reads the same review endpoints Despegar's own hotel pages serve to anonymous visitors — the only machine-readable surface that exists. No OAuth, no partner program, no login.

#### What are alternatives to this actor for hotel review data?

On the Store: [knagymate/despegar-reviews-scraper](https://apify.com/knagymate/despegar-reviews-scraper) ($0.00433/review), [korado_labs/despegar-reviews-scraper](https://apify.com/korado_labs/despegar-reviews-scraper), [haketa/despegar-reviews-scraper](https://apify.com/haketa/despegar-reviews-scraper), and free [kestrel/hotel-reputation-checker](https://apify.com/kestrel/hotel-reputation-checker). Off-Store: browser-based scrapers (100× the compute). Ours is the only one that merges traveller-type queries into a complete set.

#### How do I get every review for a hotel?

Keep `travelerType` at `all` (default). Switching to `general` cuts coverage by roughly a third for the same hotel. The merge runs one query per traveller type and de-duplicates by Despegar review id.

#### Why is my run returning nothing / HTTP 403?

Despegar rejects all datacenter IPs — including Apify's own servers and Apify Datacenter proxies — with 403. The default `proxyConfiguration` (Apify Proxy, `RESIDENTIAL` group) is required. Also check that the proxy country matches the market: a random-country pool can get a `despegar.com.ar` hotel rejected while the same hotel succeeds pinned to `AR`.

#### Why does my small, capped run return only one traveller type?

`maxReviewsPerHotel` stops the crawl as soon as the budget is met, and the traveller-type queries run concurrently — so a small cap is filled by whichever stream answers first. For a representative mix leave it at `0`, or set `travelerType` to one type on purpose.

#### Can I scrape reviews by date or only new ones?

Set `cutoffDate` to a `YYYY-MM` month. Reviews are filtered as they stream in, so the run fetches only the pages it needs and stays cheap.

#### Does it work for Brazil?

No — `www.despegar.com.br` fails DNS resolution (confirmed locally and from Apify cloud infrastructure). Use a different country domain for Brazilian properties.

#### How much does the hotel summary cost?

One `hotelSummary` item per hotel at $0.00009 — roughly 16× cheaper than a single review row. It carries the aggregate score, six category scores, review count and Despegar's AI summary.

### For AI Agents & LLM Apps

- **Purpose**: given Despegar hotel page URLs, returns one row per guest review (score, month, traveller type, separated liked/disliked comments) plus one summary row per hotel with category scores — complete sets via traveller-type merge.
- **Minimal working input**:

```json
{ "startUrls": [{ "url": "https://www.us.despegar.com/hotels/h-352691/bluebay-grand-esmeralda-all-inclusive-riviera+maya" }], "maxReviewsPerHotel": 0, "travelerType": "all" }
```

- **Variant inputs** — date window: add `"cutoffDate": "2025-01"`; targeted audience: `"travelerType": "family"`; multi-market: add `"url"` entries with different country domains; skip hotel pages: `"fetchHotelPages": false`.
- **Output fields**: `hotelName, hotelId, hotelUrl, reviewerName, reviewerCountry, reviewerCountryCode, travelerType, travelerTypeLabel, language, locale, date, dateMonth, dateIso, rating, ratingLabel, positiveComment, negativeComment, usefulCount, provider, providerLabel, scrapedAt` (reviews dataset) and `hotelName, hotelUrl, score, generalRating, reviewCount, categories, generatedReview` (hotels dataset).
- **Behaviors an agent should know**: `travelerType: "all"` (default) is required for a complete review set — the unfiltered query alone omits ~1/3 of reviews; a single-type value is deliberately cheaper but partial. `cutoffDate` takes `YYYY-MM` only (Despegar has month granularity — never pass a day). `startUrls` must be objects with a `url` key, not bare strings. `fetchHotelPages: false` leaves `hotelName` empty but saves one request per hotel. A small `maxReviewsPerHotel` biases the sample to whichever traveller-type stream answers first — leave it `0` for a representative mix. Reviews are not sorted regardless of any order parameter. Residential proxy is mandatory in the cloud: keep `apifyProxyGroups: ["RESIDENTIAL"]`; for a single country pin `proxyCountry` to the ISO code. Output splits across two datasets: `reviews` and `default`/`hotels`.
- **Billing**: pay-per-event — $0.0015 per review + $0.00009 per hotel summary + standard $0.00005 actor start; residential proxy traffic is billed separately by Apify only when used.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Despegar.com or Despegar Group**. It accesses only review data Despegar's own website serves to anonymous visitors — it does not log in, bypass access controls, solve CAPTCHAs or use any private API. Review records include personal data published by Despegar (reviewer first name, country): treat it accordingly — do not use it for profiling or unsolicited outreach, and check whether GDPR, CCPA or local equivalents apply before you store or redistribute it. Users are responsible for their own compliance with Despegar's Terms of Service, `robots.txt` and applicable law. Data is intended for legitimate purposes such as reputation monitoring, market research and competitive analysis.

### SEO Keywords

despegar scraper, despegar hotel reviews, hotel review scraping, hotel reputation monitoring, guest reviews dataset, travel review data, hotel rating analysis, voice of customer hotels, latam hotel reviews, despegar reviews api alternative, hotel category scores, hospitality market research, hotel competitor benchmarking, reseñas de hoteles despegar, hotel feedback analysis, review monitoring dashboard, hotel guest satisfaction data, mexico hotel reviews, argentina hotel reviews, colombia hotel reviews

# Actor input Schema

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

Despegar hotel page URLs to scrape reviews from. The country domain in each URL decides the language and country sent to the API, so mix domains freely (for example despegar.com.ar and us.despegar.com).

## `maxHotels` (type: `integer`):

Maximum number of hotels to scrape. Extra URLs are ignored once this limit is reached.

## `maxReviewsPerHotel` (type: `integer`):

Maximum reviews to collect per hotel. Use 0 for every review the endpoint returns.

## `cutoffDate` (type: `string`):

Only keep reviews from this month onwards, formatted YYYY-MM. Despegar publishes review dates with month granularity only, so a day component is not possible.

## `locale` (type: `string`):

Force the language and country sent to the API, formatted like es-MX or pt-BR. Leave empty to derive it from each start URL's domain, which is the recommended setting.

## `travelerType` (type: `string`):

Which traveler-type queries to run. "all" runs every one of them and merges the results, which is the only way to reach a hotel's full review set — the unfiltered query on its own silently omits roughly a third of reviews. Pick a single type for targeted analysis at lower cost.

## `reviewPageSize` (type: `integer`):

Reviews fetched per request. The endpoint accepts at most 100; higher values mean fewer requests per hotel.

## `includeHotelSummary` (type: `boolean`):

Emit one hotelSummary item per hotel with the aggregate score, the six category scores, the review count and Despegar's AI review summary.

## `fetchHotelPages` (type: `boolean`):

Fetch each hotel page to capture the hotel name. The hotel id is taken from the URL either way, so turning this off saves one request per hotel and leaves hotelName empty.

## `maxRequestsPerCrawl` (type: `integer`):

Safety cap on total requests. Use 0 for no limit.

## `maxConcurrency` (type: `integer`):

Parallel requests. Despegar serves these endpoints cheaply, so 10 is comfortable; lower it if you hit rate limiting.

## `proxyCountry` (type: `string`):

Pin the residential proxy to a specific country, as an ISO code such as AR, MX or BR. Leave empty to pin each hotel to the country of its own domain, which is the recommended setting — Despegar rejects far more requests when a market is reached through a foreign exit IP.

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

Despegar rejects all requests from datacenter IP addresses with HTTP 403, which includes Apify's own servers and Apify Datacenter proxies. Residential proxies are therefore required to run this Actor in the cloud, and the default below turns them on. If a run returns 403, check this first.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.us.despegar.com/hotels/h-352691/bluebay-grand-esmeralda-all-inclusive-riviera+maya"
    }
  ],
  "maxHotels": 20,
  "maxReviewsPerHotel": 0,
  "cutoffDate": "",
  "locale": "",
  "travelerType": "all",
  "reviewPageSize": 100,
  "includeHotelSummary": true,
  "fetchHotelPages": true,
  "maxRequestsPerCrawl": 0,
  "maxConcurrency": 10,
  "proxyCountry": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `hotels` (type: `string`):

One item per hotel, with the aggregate score, the six category scores, the review count and the AI review summary. Billed as a 'hotel' pay-per-result event.

## `reviews` (type: `string`):

One item per guest review, de-duplicated by Despegar review id. Billed as a 'review' pay-per-result event.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.us.despegar.com/hotels/h-352691/bluebay-grand-esmeralda-all-inclusive-riviera+maya"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/despegar-reviews-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 = { "startUrls": [{ "url": "https://www.us.despegar.com/hotels/h-352691/bluebay-grand-esmeralda-all-inclusive-riviera+maya" }] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/despegar-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.us.despegar.com/hotels/h-352691/bluebay-grand-esmeralda-all-inclusive-riviera+maya"
    }
  ]
}' |
apify call ahmed_jasarevic/despegar-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/despegar-reviews-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/NWx9pXtLqYX6k9t47/builds/zITUncok5BvPHGJvr/openapi.json