# Agoda Reviews Scraper (`scrapesmith/agoda-reviews-scraper`) Actor

Scrape thousands of verified guest reviews from any Agoda hotel. Extract ratings, review text, pros and cons, traveler type, room type, check-in dates, and reviewer country. Supports bulk hotels and exports to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapesmith/agoda-reviews-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Agoda Reviews Scraper

Extract thousands of verified guest reviews from any Agoda hotel — including Booking.com reviews displayed on Agoda. Scrape ratings, full review text, pros and cons, traveler profiles, room details, hotel management responses, and aggregate rating breakdowns from hotels, resorts, hostels, apartments, and villas listed on Agoda.com. The fastest and most affordable Agoda review scraper on the market.

### What This Actor Does

Scrape comprehensive review data from any Agoda-listed accommodation worldwide — hotels, resorts, serviced apartments, hostels, villas, and guesthouses across 200+ countries:

- **Ratings & sentiment** — numeric score, rating labels (Exceptional, Excellent, Very Good, Good), and aggregate category breakdowns (cleanliness, location, staff, value, comfort, facilities)
- **Full review text** — title, main comment, positives, and negatives separated into distinct fields
- **Guest profile** — reviewer name, country of origin, traveler type (couple, family, solo traveler, business, group)
- **Stay details** — room type booked, check-in/check-out dates, length of stay in nights
- **Hotel responses** — full management reply text, responder name, and response date
- **Engagement signals** — helpful votes count, guest-uploaded review photos
- **Multi-source reviews** — scrape Agoda reviews, Booking.com reviews, or both simultaneously in a single run
- **Smart filters** — filter by rating level, review language, or cutoff date to get exactly the reviews you need
- **Review counts** — total Agoda and Booking.com review counts per hotel

### Features

- Scrape **2,000+ reviews** from a single hotel in under 2 minutes — over 1,900 reviews per minute
- Process **multiple hotels** in one run — no need to start separate runs for each property
- Automatic **resume on interruption** — picks up where it left off if the run migrates or restarts
- Filter reviews by **rating** (Exceptional 9+, Excellent 8-9, Very Good 7-8, Good 6-7, Below Expectation)
- Filter by **language** — English, French, German, Spanish, Japanese, Korean, Chinese, Thai, and 20+ more
- Set a **cutoff date** to only collect reviews after a specific date — ideal for ongoing monitoring
- Include **aggregate ratings** with category-level breakdown scores per hotel
- Choose from **4 sort orders** — most recent, highest rating, lowest rating, or most helpful
- Works with both **hotel URLs and numeric hotel IDs** — use whichever is more convenient
- Export to **JSON, CSV, Excel, or HTML**

### Input

```json
{
  "hotelUrls": [
    "https://www.agoda.com/mandarin-oriental-bangkok/hotel/bangkok-th.html",
    "5000"
  ],
  "maxReviews": 500,
  "sortBy": "recent",
  "ratingFilter": "all",
  "enabledProviders": ["Agoda", "Booking.com"],
  "cutoffDate": "2025-01-01",
  "aggregateRatings": true,
  "language": "en-us"
}
````

#### Input Fields

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `hotelUrls` | array | *Required* | Agoda hotel page URLs or numeric hotel IDs |
| `maxReviews` | integer | 500 | Maximum reviews to extract per hotel (up to 10,000) |
| `sortBy` | select | recent | Sort order: `recent`, `rating_high`, `rating_low`, or `helpful` |
| `ratingFilter` | select | all | Filter by rating: `all`, `exceptional`, `excellent`, `very_good`, `good`, `below_expectation` |
| `enabledProviders` | array | Both | Review sources to include: `Agoda`, `Booking.com`, or both |
| `cutoffDate` | string | — | Only return reviews after this date (YYYY-MM-DD) |
| `aggregateRatings` | boolean | false | Include hotel-level aggregate scores and review counts in each review |
| `language` | string | en-us | Language locale for the review page |

### Output

Each review contains up to 25 fields:

```json
{
  "reviewId": 1132543983,
  "rating": 10.0,
  "ratingText": "Exceptional",
  "title": "Outstanding stay",
  "text": "Beautiful hotel with excellent service throughout our stay...",
  "positives": "Location, cleanliness, staff friendliness",
  "negatives": "",
  "authorName": "Nathan",
  "country": "Australia",
  "travellerType": "Couple",
  "roomType": "Premier Room",
  "checkInDate": "2025-12-13T00:00:00+07:00",
  "checkOutDate": "2025-12-14T00:00:00+07:00",
  "reviewDate": "2026-06-15T11:55:00+07:00",
  "lengthOfStay": 1,
  "helpfulVotes": 0,
  "images": [],
  "hotelResponse": "Mercure Sydney",
  "responseText": "Thank you for taking the time to share your great experience. We hope to see you again very soon.",
  "responseDate": "2026-06-17T10:54:18.7+07:00",
  "provider": "Agoda",
  "hotelId": 5000,
  "aggregateRatings": {
    "overallScore": 8.9,
    "cleanliness": 9.1,
    "location": 9.4,
    "staff": 9.0,
    "value": 8.5,
    "comfort": 8.8,
    "facilities": 8.7,
    "agodaReviewsCount": 2086,
    "bookingReviewsCount": 4759
  },
  "scrapedAt": "2026-07-05T09:00:00.000000+00:00"
}
```

### Pricing

- **Free tier:** 25 reviews per run — no credit card required, try it now
- **Paid plans:** from **$2.00 per 1,000 reviews** — up to 75% less than comparable Agoda scrapers

Pay only for results delivered. No subscriptions, no platform fees, no setup costs.

### Use Cases

- **Hotel owners & managers** — track guest sentiment across Agoda and Booking.com reviews in one dashboard
- **Travel agencies** — compare hotel quality across destinations before recommending properties to clients
- **Market researchers** — analyze hospitality trends, service quality benchmarks, and regional satisfaction patterns at scale
- **Revenue & pricing managers** — monitor how competitor pricing decisions impact guest perception and ratings
- **Investment & acquisition teams** — evaluate property reputation, review volume, and guest satisfaction before hotel acquisitions
- **Content & marketing teams** — source authentic guest testimonials, identify top-performing properties, and track brand mentions
- **Data scientists & AI teams** — build sentiment analysis models, train NLP classifiers, or feed review data into recommendation engines

### Tips

- Use **numeric hotel IDs** for the fastest results — find them in the Agoda URL or page source
- Enable **aggregateRatings** to get category-level scores (cleanliness, location, staff, value, comfort, facilities) alongside individual reviews
- Set **cutoffDate** to focus on recent feedback when monitoring ongoing service quality
- Use **both providers** (Agoda + Booking.com) to get the most complete review coverage — some hotels have 2x more Booking.com reviews than Agoda reviews
- Combine **ratingFilter** with **sortBy** to quickly find the most critical or most positive reviews

### Support

For issues or feature requests, open an issue on the Actor page or contact: shamrozakram99@gmail.com

# Actor input Schema

## `hotelUrls` (type: `array`):

Agoda hotel page URLs or numeric hotel IDs

## `maxReviews` (type: `integer`):

Maximum reviews to extract per hotel

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

Review sort order

## `language` (type: `string`):

Language locale

## `ratingFilter` (type: `string`):

Only return reviews within this rating range

## `enabledProviders` (type: `array`):

Which review sources to include

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

Only return reviews after this date (YYYY-MM-DD)

## `aggregateRatings` (type: `boolean`):

Include hotel aggregate score breakdown (cleanliness, location, staff, value, comfort, facilities) in each review

## Actor input object example

```json
{
  "hotelUrls": [
    "69025"
  ],
  "maxReviews": 500,
  "sortBy": "recent",
  "language": "en-us",
  "ratingFilter": "all",
  "enabledProviders": [
    "Agoda",
    "Booking.com"
  ],
  "aggregateRatings": false
}
```

# 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 = {
    "hotelUrls": [
        "69025"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/agoda-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 = { "hotelUrls": ["69025"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/agoda-reviews-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "hotelUrls": [
    "69025"
  ]
}' |
apify call scrapesmith/agoda-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesmith/agoda-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Agoda Reviews Scraper",
        "description": "Scrape thousands of verified guest reviews from any Agoda hotel. Extract ratings, review text, pros and cons, traveler type, room type, check-in dates, and reviewer country. Supports bulk hotels and exports to JSON, CSV or Excel.",
        "version": "0.0",
        "x-build-id": "mzPQMJvLBkguOJnYj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~agoda-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-agoda-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesmith~agoda-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-agoda-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesmith~agoda-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-agoda-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "hotelUrls"
                ],
                "properties": {
                    "hotelUrls": {
                        "title": "Hotel URLs or IDs",
                        "type": "array",
                        "description": "Agoda hotel page URLs or numeric hotel IDs",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max Reviews per Hotel",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum reviews to extract per hotel",
                        "default": 500
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "recent",
                            "rating_high",
                            "rating_low",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Review sort order",
                        "default": "recent"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language locale",
                        "default": "en-us"
                    },
                    "ratingFilter": {
                        "title": "Rating Filter",
                        "enum": [
                            "all",
                            "exceptional",
                            "excellent",
                            "very_good",
                            "good",
                            "below_expectation"
                        ],
                        "type": "string",
                        "description": "Only return reviews within this rating range",
                        "default": "all"
                    },
                    "enabledProviders": {
                        "title": "Review Providers",
                        "type": "array",
                        "description": "Which review sources to include",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Agoda",
                                "Booking.com"
                            ]
                        },
                        "default": [
                            "Agoda",
                            "Booking.com"
                        ]
                    },
                    "cutoffDate": {
                        "title": "Cutoff Date",
                        "type": "string",
                        "description": "Only return reviews after this date (YYYY-MM-DD)"
                    },
                    "aggregateRatings": {
                        "title": "Include Aggregate Ratings",
                        "type": "boolean",
                        "description": "Include hotel aggregate score breakdown (cleanliness, location, staff, value, comfort, facilities) in each review",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
