# Agoda Hotel Scraper API 💰$1/1k — Listings & Prices (`memo23/agoda-scraper`) Actor

Agoda Hotel Scraper API — search hotels & accommodations by destination + dates. Per hotel: name, star rating, review score & count, nightly price, area, city, coordinates, type, image & URL. Any city, currency & locale. Pure HTTP, no browser. $1/1k flat, JSON or CSV out.

- **URL**: https://apify.com/memo23/agoda-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Travel, Automation, Agents
- **Stats:** 17 total users, 16 monthly users, 100.0% runs succeeded, NaN 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 Hotel Scraper API — Listings, Prices, Ratings & Reviews

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/agoda-card.png" alt="Agoda Hotel Scraper" width="760">
</p>

### How It Works

![How the Agoda Hotel Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-agoda.png)

1. **Your input** — *either* a destination (city name) + dates, *or* one or more **Agoda hotel-page URLs** to scrape those exact hotels. Plus rooms, guests, currency, locale, and optionally how many **guest reviews** to pull per hotel.
2. **Search API** — for a destination, the Actor resolves it to Agoda's internal `cityId` and calls Agoda's `citySearch` API page by page; for a hotel URL it resolves the link to its `propertyId` and fetches that one hotel. Either way it decodes the full result — listings, ratings and live prices — over pure HTTP, no browser. With `maxReviews` set, it also paginates Agoda's review API for individual guest reviews.
3. **Your dataset** — flat rows or nested JSON: hotel name, star rating, review score & count, nightly price, total price, area, city, country, coordinates, type, image, a dated deep-link URL, and (optionally) an array of guest reviews — CSV-ready or JSON.

**Scrape hotels, prices, ratings and reviews from Agoda — by destination + dates, or by hotel URL — at $1 per 1,000 results.** Each hotel carries its name, star rating, guest review score and count, **live nightly and total price** in your chosen currency, area/city/country, latitude & longitude, accommodation type, a photo, and a **deep-link URL that lands on the priced page for your exact dates**. Paste a hotel link to scrape that **exact property**, and set `maxReviews` to pull **individual guest reviews** (text, rating, traveler type, room type, the hotel's reply). Pure HTTP — no browser, no CAPTCHA solver. Output is CSV-ready flat rows or nested JSON, straight into your Apify dataset.

### Why Use This Scraper?

- **$1 / 1,000 results** — flat, simple pricing, and the **cheapest Agoda listings scraper on the Store**. No opaque per-page math.
- **Listings, prices *and* reviews** — many Agoda scrapers do one or the other. This one returns **search results with live nightly + total prices** *and* optional **individual guest reviews**, for your dates and occupancy.
- **Two ways to target** — search a **whole city** by destination + dates, or paste **specific Agoda hotel URLs** to scrape exactly those properties (each link resolved to its `propertyId` automatically).
- **Guest reviews on demand** — set `maxReviews` to pull individual reviews per hotel: review **text**, title, rating, traveler type, room type, length of stay, reviewer country, the hotel's **response**, and any review photos — sorted by most recent, rating, or most-helpful.
- **No browser, no CAPTCHA solver** — pure HTTP against Agoda's own search API. Small responses, low bandwidth.
- **Rich per-hotel data** — star rating, **guest review score + count**, **amenities**, **full photo gallery**, **nearest landmark & transport with distances**, room size, area/city/country, latitude/longitude, vibe tags, and sample guest-review snippets.
- **Discounts** — `discount-percent` and the crossed-out `price-original` whenever Agoda is running a deal, plus a `free-cancellation` flag.
- **Built-in filters** — narrow by **star rating**, **price min/max**, **review score min/max**, and **property type** — the Actor paginates further so strict filters still fill up.
- **Optional deep detail** — flip on `includeDetails` to add per-category **review sub-scores** (cleanliness, location, staff, value…) with city averages, score distribution, a 30-day review trend, the hotel **description**, and **AI review highlights** (one extra call per hotel).
- **Dated deep links** — every row's `url` carries your check-in, nights and occupancy, so it opens the hotel on the priced page — ready for click-through.
- **Sold-out aware** — unavailable hotels are flagged `sold-out: true` and still carry an indicative price, so nothing silently drops out.
- **Global** — any city, any `currency`, any `market` (locale).
- **Spreadsheet or JSON** — flat dashed columns (`price-per-night`, `review-score`…) for Excel/Sheets, or nested objects for pipelines.

### Overview

This Actor harvests structured hotel results from Agoda over pure HTTP, two ways: by **destination** (it resolves the city to Agoda's `cityId`, posts the `citySearch` API, and paginates the full sorted result set) or by **hotel URL** (it resolves each link to its `propertyId` and fetches that exact property). Either way it parses each property's content, ratings and pricing — and, when `maxReviews` is set, paginates Agoda's review API for individual guest reviews.

Output is **one row per hotel**. Each row carries identity (name, type, star rating), reputation (review score + count), pricing (per-night + total, in your currency), location (area/city/country + coordinates), a photo, a dated booking deep-link, and — when requested — a nested array of guest `reviews`.

### Supported Inputs

| Input | What it does |
|---|---|
| **Destination** | `location` — a city or destination name, e.g. `Bangkok`, `London`, `New York`. Resolved to Agoda's `cityId` automatically. |
| **Hotel URLs** | `startUrls` — one or more Agoda hotel-page links (e.g. `https://www.agoda.com/<hotel>/hotel/<city>-<cc>.html`) to scrape those **exact** hotels. When set, the destination search is skipped. Each URL is resolved to its `propertyId` automatically. |
| **Dates** | `checkIn` (`YYYY-MM-DD`) plus `nights`, **or** a `checkOut` date (nights is derived from it). |
| **Occupancy** | `rooms`, `adults`, `children`, and optional `childAges`. |
| **Reviews (optional)** | `maxReviews` — individual guest reviews to pull per hotel (text, rating, traveler type, room type, hotel reply, photos); `reviewsSort` orders them. `0` = off. |
| **Sort** | `sortField`: `Ranking` (default) · `Price` · `Recommended` · `Review` · `Distance`. |
| **Filters** | `starRatings`, `priceMin` / `priceMax`, `minReviewScore` / `maxReviewScore`, `propertyTypes`. All optional; the Actor paginates further when a page is filtered out, so strict filters still fill up to `maxItems`. |
| **Detail (optional)** | `includeDetails` — per-hotel review sub-scores (with city averages), score distribution, 30-day trend, description & AI review highlights. |
| **Currency & locale** | `currency` (ISO 4217, e.g. `USD`, `THB`) and `market` (locale, e.g. `en-gb`). |
| **Volume** | `maxItems` — how many hotels to return; the Actor paginates until it reaches it. |

**Not supported:** flights or car hire, live booking/checkout, room-level rate-plan breakdowns. This Actor returns hotel search listings + headline prices (plus guest reviews on request).

### Use Cases

| Audience | What they do with it |
|---|---|
| **Travel aggregators / OTAs** | Power a hotel-comparison page across many cities and dates. |
| **Revenue / pricing teams** | Benchmark competitor hotel prices and rating bands over time. |
| **Hotels & hostels** | Track how rivals in the same area are priced and reviewed. |
| **Rate-shopping products** | Snapshot nightly prices per city + date daily and alert on moves. |
| **Reputation & CX teams** | Pull individual guest reviews (text, rating, traveler type, room type, hotel replies) for specific hotels by URL to mine sentiment and service gaps. |
| **Data & ML pipelines** | Ingest hotel price + review data to model demand and seasonality. |
| **Researchers** | Build open hotel price/quality datasets for a destination. |

### Input Configuration

| Field | Type | Required | Notes |
|---|---|---|---|
| `startUrls` | array | — | Agoda hotel-page URLs to scrape exactly those hotels. When set, `location` is ignored. Each link is resolved to its `propertyId` automatically. |
| `location` | string | — | City / destination name, e.g. `Bangkok`. Defaults to `London`. Used only when `startUrls` is empty. |
| `checkIn` | string | — | `YYYY-MM-DD`. Defaults to ~30 days out if empty. |
| `checkOut` | string | — | Optional. If set, `nights` is derived from it. |
| `nights` | integer | — | Length of stay (ignored when `checkOut` is given). Default 1. |
| `rooms` | integer | — | Default 1. |
| `adults` | integer | — | Default 2. |
| `children` | integer | — | Default 0. |
| `childAges` | array | — | Ages of children, e.g. `[5, 9]` — only used when `children` > 0. |
| `sortField` | enum | — | `Ranking` · `Price` · `Recommended` · `Review` · `Distance`. Default `Ranking`. |
| `currency` | string | — | ISO 4217, e.g. `USD`, `EUR`, `THB`. Default `USD`. |
| `market` | string | — | Locale, e.g. `en-gb`, `en-us`, `de-de`. Default `en-gb`. |
| `maxItems` | integer | — | Max hotels to return. Default 100. |
| `maxReviews` | integer | — | Individual guest reviews to scrape per hotel (text, rating, traveler/room type, hotel reply, photos). `0` = off (default). Paginates extra requests per hotel, so large values × many hotels run slower. |
| `reviewsSort` | enum | — | Order reviews are scraped in: `Most recent` (default) · `Highest rated` · `Lowest rated` · `Most helpful`. Only used when `maxReviews` > 0. |
| `includeDetails` | boolean | — | Add per-hotel detail: review sub-scores (with city averages), score distribution, 30-day trend, description, AI highlights. One extra request per hotel. Default `false`. |
| `starRatings` | array | — | Keep only these star ratings, e.g. `["4","5"]`. Half-stars floor to their tier (a 4.5★ is a 4-star match). Empty = any. |
| `priceMin` / `priceMax` | integer | — | Nightly-price band in the selected currency. Empty = no bound. |
| `minReviewScore` / `maxReviewScore` | number | — | Guest review-score band (Agoda 0–10). Empty = no bound. |
| `propertyTypes` | array | — | Keep only these types, e.g. `["hotel","resort"]` (matched against each hotel's `type`). Empty = all. |
| `proxy` | object | — | Residential proxy, **on by default** (recommended for reliable, geo-consistent pricing). |

Everything is optional — run it with no input at all and it searches **London, ~30 days out, 1 night, 2 adults** as a sane default. Set `location` + `checkIn` for a normal search.

#### Example input

```json
{
  "location": "Bangkok",
  "checkIn": "2026-08-03",
  "nights": 2,
  "rooms": 1,
  "adults": 2,
  "currency": "USD",
  "market": "en-gb",
  "sortField": "Ranking",
  "maxItems": 100
}
````

Filtered — 5-star hotels under $150/night with a strong review score, check-out date instead of nights:

```json
{
  "location": "London",
  "checkIn": "2026-09-10",
  "checkOut": "2026-09-13",
  "adults": 2,
  "sortField": "Price",
  "currency": "GBP",
  "starRatings": ["5"],
  "priceMax": 150,
  "minReviewScore": 8,
  "maxItems": 50
}
```

Specific hotels by URL, with 20 guest reviews each (most recent first):

```json
{
  "startUrls": [
    { "url": "https://www.agoda.com/the-savoy/hotel/london-gb.html" },
    { "url": "https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html" }
  ],
  "maxReviews": 20,
  "reviewsSort": "Most recent",
  "currency": "USD",
  "market": "en-gb"
}
```

### Output Overview

One row per **hotel** — in the order Agoda returns them for your chosen sort, or in `startUrls` order when you scrape by URL. Available hotels carry a live nightly + total price; sold-out hotels are flagged `sold-out: true` and carry an indicative average price. Each row's `url` is a dated deep-link to the hotel's priced page. When `maxReviews` > 0, each row also carries a nested `reviews` array and a `scraped-review-count`.

### Output Samples

Real smoke-test row (Bangkok, 2 nights, 2 adults) — abbreviated arrays:

```jsonc
{
  "index": 0,
  "property-id": 14654101,
  "name": "Solaria Nishitetsu Hotel Bangkok",
  "type": "Hotel",
  "star-rating": 4,
  "review-score": 9.2,
  "review-count": 16382,
  "price-per-night": 127.56,
  "price-total": 510.24,
  "price-original": 175.52,
  "discount-percent": 27,
  "currency": "USD",
  "free-cancellation": false,
  "room-size-sqm": 25,
  "area": "Sukhumvit",
  "city": "Bangkok",
  "country": "Thailand",
  "latitude": 13.73682,
  "longitude": 100.560272,
  "distance-from-center-km": 0,
  "nearest-landmark": "Siam Paragon",
  "nearest-landmark-m": 2965,
  "nearest-transport": "Asok BTS Station",
  "nearest-transport-m": 27,
  "top-landmarks": ["Siam Paragon", "MBK Center", "Jim Thompson House"],
  "amenities": ["Swimming pool", "Free Wi-Fi in all rooms!", "Balcony/terrace", "Desk", "Private pool"],
  "atmospheres": ["shopping", "business center", "nightlife", "restaurants"],
  "review-snippets": ["Location is right next to both BTS-Asok and MRT-Sukhumvit.", "From the location to the staff, everything is perfect!"],
  "top-selling-point": "Cheapest Four Star Rating",
  "is-popular": false,
  "sustainable": false,
  "sold-out": false,
  "image": "https://pix8.agoda.net/hotelImages/14654101/0/…",
  "images": ["https://pix8.agoda.net/…", "https://pix8.agoda.net/…"],
  "image-count": 10,
  "url": "https://www.agoda.com/solaria-nishitetsu-hotel-bangkok/hotel/bangkok-th.html?checkIn=2026-08-03&los=2&rooms=1&adults=2&children=0&currencyCode=USD&cid=-1",
  "check-in": "2026-08-03",
  "nights": 2,
  "rooms": 1,
  "adults": 2,
  "children": 0,
  "agoda-city-id": 9395
}
```

With `maxReviews` set, each row also carries `scraped-review-count` and a `reviews` array — one object per guest review:

```jsonc
{
  "scraped-review-count": 20,
  "reviews": [
    {
      "reviewId": 1002362394,
      "title": "Wonderful!",
      "text": "Loved our three night stay at The Savoy. For a special occasion, we pushed the boat out…",
      "positives": null,
      "negatives": null,
      "rating": 9.6,
      "ratingText": "Exceptional",
      "date": "2025-08-02T02:10:00+07:00",
      "checkInMonth": "July 2025",
      "lengthOfStay": 3,
      "roomType": "Superior Queen Room",
      "travelerType": "Couple",
      "reviewer": "Helen",
      "reviewerCountry": "United Kingdom",
      "provider": "Agoda",
      "helpfulVotes": 0,
      "response": { "by": "The Savoy Hotel", "text": "Dear Helen, We are so happy to receive your review…", "date": "Responded December 10, 2025" },
      "images": []
    }
  ]
}
```

> Reviews come from every provider Agoda aggregates (Agoda's own guests, Booking.com, …) — each review's `provider` field tells you which. Booking.com-style reviews split into liked/disliked, surfaced in `positives` / `negatives` and merged into `text`.

### Key Output Fields

**Identity**

- `property-id` — Agoda's internal hotel id
- `name`, `type` (e.g. `Hotel`, `Hostel`, `Resort`)
- `star-rating` — official star rating (0 when unrated)

**Reputation**

- `review-score` — guest review score (e.g. 8.6 / 10)
- `review-count` — number of guest reviews

**Pricing**

- `price-per-night`, `price-total` — in the selected `currency`
- `price-original`, `discount-percent` — the crossed-out price + % off when Agoda is running a deal
- `free-cancellation` — `true` when the cheapest offer is free-cancellation
- `sold-out` — `true` when unavailable for the dates (price is then an indicative average)

**Property detail**

- `room-size-sqm` — size of the cheapest room
- `amenities` — array of facilities (e.g. Swimming pool, Free Wi-Fi, Balcony, Private pool)
- `atmospheres` — vibe tags (e.g. shopping, nightlife, business center)
- `review-snippets` — sample guest-review quotes
- `top-selling-point`, `is-popular`, `sustainable`

**Location**

- `area`, `city`, `country`, `latitude`, `longitude`
- `distance-from-center-km`
- `nearest-landmark` + `nearest-landmark-m`, `nearest-transport` + `nearest-transport-m`, `top-landmarks`

**Media & link**

- `image` — primary photo URL · `images` — full gallery · `image-count`
- `url` — dated deep-link that opens the hotel on the priced page for your search

**Detailed scores & content** (only when `includeDetails` is on)

- `score-overall`, `score-cleanliness`, `score-facilities`, `score-location`, `score-staff`, `score-value` — per-category review sub-scores
- `review-grades` — full array with each category's score **and the city average** to benchmark against
- `score-distribution` — review counts per band (exceptional → below-expectation)
- `review-trend-30d` — 30-day review-score trend (positive = improving)
- `description` — hotel description
- `detail-highlights` — AI-summarized review highlights

**Guest reviews** (only when `maxReviews` > 0)

- `scraped-review-count` — how many reviews were pulled for this hotel
- `reviews[]` — one object per review: `text` (full comment), `title`, `rating` (0–10) + `ratingText`, `positives` / `negatives`, `date` + `checkInMonth`, `lengthOfStay`, `roomType`, `travelerType`, `reviewer` + `reviewerCountry`, `provider`, `helpfulVotes`, the hotel's `response` (reply), and review `images`

**Search echo**

- `check-in`, `nights`, `rooms`, `adults`, `children`, `agoda-city-id`

### FAQ

**Is this an official Agoda API?**
No. It's an independent scraper that reads publicly available Agoda hotel search results. Not affiliated with or endorsed by Agoda.

**Can I scrape one specific hotel instead of a whole city?**
Yes — put the Agoda hotel-page URL(s) in `startUrls` (e.g. `https://www.agoda.com/the-savoy/hotel/london-gb.html`). The Actor resolves each link to its hotel id and returns that exact property as a full priced row. When `startUrls` is set, the `location` search is skipped. Pass several URLs to scrape a fixed list of hotels.

**Does it scrape individual guest reviews?**
Yes — set `maxReviews` to the number of reviews you want per hotel and each row gets a `reviews` array: review **text**, title, rating, traveler type, room type, length of stay, reviewer country, the hotel's reply, and any review photos. Order them with `reviewsSort` (`Most recent`, `Highest rated`, `Lowest rated`, `Most helpful`). Works in both destination and hotel-URL mode. Reviews are aggregated across every provider Agoda shows (its own guests, Booking.com, …), each tagged with its `provider`.

**Do I need a proxy?**
A residential proxy is on by default and recommended — it gives reliable, geo-consistent pricing and avoids rate-limiting. Agoda has no CAPTCHA, but datacenter IPs can be throttled. Responses are small, so bandwidth cost is minimal.

**Does it return real prices, or just hotel names?**
Real prices. Every available hotel carries a live **nightly and total price** for your dates and occupancy, in your chosen currency — not just the listing.

**What about sold-out hotels?**
They're kept and flagged `sold-out: true`, with an indicative average price (the greyed price Agoda shows), so your dataset stays complete.

**Can I filter the results?**
Yes — by `starRatings`, nightly price (`priceMin` / `priceMax`), guest review score (`minReviewScore` / `maxReviewScore`), and `propertyTypes`. Filters are applied as the Actor paginates, so a strict filter keeps fetching more pages until it fills `maxItems` or the city runs out — you never get a short result set just because the first page didn't match.

**Does it include amenities and photos?**
Yes — every row carries an `amenities` list, the full photo `images` gallery, `room-size-sqm`, `nearest-landmark` / `nearest-transport` with distances, vibe `atmospheres`, and sample `review-snippets` — all at the same $1/1,000, no extra calls or detail-page fetches.

**What currency / locale?**
`currency` (ISO 4217, e.g. `USD`, `EUR`, `THB`) and `market` (locale, e.g. `en-gb`). Defaults USD / en-gb.

**How many hotels per search?**
The Actor paginates Agoda's full result set for the city (dozens of hotels per page) up to your `maxItems`. Run many city × date searches to build a larger dataset.

**Can I sort the results?**
Yes — `sortField`: `Ranking` (default), `Price`, `Recommended`, `Review` or `Distance`.

**Is the URL ready to open?**
Yes — each `url` carries your check-in, nights and occupancy, so it lands on the hotel's priced page for that exact search.

### Support

Found a bug or need a field that isn't exposed? Open an issue on the Actor's **Issues** tab on Apify, or reach out via the Apify Store profile. Include your input JSON and the run ID.

### Additional Services

Need a custom hotel or travel data pipeline — a different source, a bespoke schema, scheduled delivery to S3/BigQuery, or rate-shopping with alerts? Custom scraping and data-engineering work is available via the Apify Store profile.

### Explore More Scrapers

- **Agoda Reviews Scraper** — `memo23/agoda-reviews-scraper` — dedicated review scraper for pulling **all** of a hotel's guest reviews at scale (this Actor already covers reviews inline via `maxReviews`; reach for the dedicated one for full-history review dumps).
- **Google Flights Scraper** — `memo23/google-flights-scraper` — fares, segments, aircraft/legroom, multi-city & booking options.
- **Skyscanner Flight Scraper** — `memo23/skyscanner-scraper` — 180+ fields per itinerary, Best/Cheapest/Fastest tags, OTA aggregation.
- **140+ other scrapers** — see the developer's Apify Store profile.

### ⚠️ Disclaimer

This Actor accesses publicly available hotel search data on Agoda for legitimate research, market-intelligence and business-analysis purposes. It is **not affiliated with, endorsed by, or sponsored by Agoda Company Pte. Ltd.** "Agoda" is a trademark of its respective owner; it is used here only to describe the data source. Use of this Actor must comply with Agoda's Terms of Service and all applicable laws, including data-protection regulations (GDPR, CCPA, etc.). The Actor's authors are not responsible for any misuse. Users must:

- Respect rate limits and avoid overloading Agoda's infrastructure
- Not use scraped data to violate user privacy or terms
- Use the data in compliance with applicable jurisdictions
- Not republish scraped content in violation of copyright

We do not store any scraped data; the Actor returns it directly to your Apify dataset for your authorized use.

### SEO Keywords

agoda scraper, agoda api, agoda hotel scraper, hotel scraper, hotel price scraper, hotel data api, agoda price scraper, hotel rates scraper, hotel reviews scraper, hotel ratings scraper, accommodation scraper, travel data api, hotel listing scraper, hotel availability scraper, agoda json export, agoda csv export, hotel price monitoring, rate shopping api, hotel price tracker, hotel comparison data, city hotel scraper, apify hotel scraper, agoda data extraction, hotel deals scraper

# Actor input Schema

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

Optional. Paste one or more Agoda hotel-page URLs (e.g. https://www.agoda.com/alkhayma-medina/hotel/marrakech-ma.html) to scrape those exact hotels. When provided, the destination/date search below is ignored and each URL is returned as a full priced row — name, nightly price, star rating, review score & count, location, amenities, image — resolved to its Agoda propertyId automatically. Combine with 'Include detailed review scores' for per-category sub-scores and description.

## `location` (type: `string`):

City or destination to search, e.g. London, Bangkok, New York. Resolved to Agoda's cityId automatically. Defaults to London. (Ignored when Hotel URLs are provided above.)

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

Check-in date. Leave empty to default to ~30 days from today (so the Actor always runs out of the box).

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

Check-out date. If set, the number of nights is derived from it. Otherwise 'Nights' is used.

## `nights` (type: `integer`):

Length of stay in nights (ignored if a check-out date is given). Default 1.

## `rooms` (type: `integer`):

Number of rooms.

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

Number of adult guests.

## `children` (type: `integer`):

Number of child guests.

## `childAges` (type: `array`):

Ages of the children, e.g. \[5, 9]. Only used when Children > 0.

## `sortField` (type: `string`):

How to sort the hotel results.

## `currency` (type: `string`):

ISO 4217 currency code for prices, e.g. USD, EUR, GBP, THB.

## `market` (type: `string`):

Site locale, e.g. en-gb, en-us, de-de. Affects language and some pricing.

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

Maximum number of hotels to return.

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

For each hotel, fetch its detail page to add per-category review sub-scores (cleanliness, location, staff, value…) with city averages, score distribution, 30-day review trend, description, and AI review highlights. Adds one extra request per hotel, so runs are slower.

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

Scrape up to this many individual guest reviews per hotel — review text, title, rating, traveler type, room type, length of stay, reviewer country, the hotel's response, and any review photos. 0 = skip reviews (default). Works in both modes; paginates extra requests per hotel, so large values × many hotels run slower.

## `reviewsSort` (type: `string`):

Order in which guest reviews are scraped (only used when 'Guest reviews per hotel' is above 0).

## `starRatings` (type: `array`):

Keep only hotels with these official star ratings. Empty = any.

## `propertyTypes` (type: `array`):

Keep only these accommodation types (matched against each hotel's type). Empty = all.

## `priceMin` (type: `integer`):

Only hotels with a nightly price at or above this (in the selected currency). Empty = no minimum.

## `priceMax` (type: `integer`):

Only hotels with a nightly price at or below this (in the selected currency). Empty = no maximum.

## `minReviewScore` (type: `number`):

Only hotels with a guest review score at or above this (Agoda scale 0-10). Empty = no minimum.

## `maxReviewScore` (type: `number`):

Only hotels with a guest review score at or below this (Agoda scale 0-10). Empty = no maximum.

## `proxy` (type: `object`):

Residential proxy is recommended (and on by default).

## Actor input object example

```json
{
  "location": "Bangkok",
  "checkIn": "2026-08-03",
  "nights": 1,
  "rooms": 1,
  "adults": 2,
  "children": 0,
  "sortField": "Ranking",
  "currency": "USD",
  "market": "en-gb",
  "maxItems": 100,
  "includeDetails": false,
  "maxReviews": 0,
  "reviewsSort": "Most recent",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "location": "London"
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/agoda-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 = { "location": "London" }

# Run the Actor and wait for it to finish
run = client.actor("memo23/agoda-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 '{
  "location": "London"
}' |
apify call memo23/agoda-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Agoda Hotel Scraper API 💰$1/1k — Listings & Prices",
        "description": "Agoda Hotel Scraper API — search hotels & accommodations by destination + dates. Per hotel: name, star rating, review score & count, nightly price, area, city, coordinates, type, image & URL. Any city, currency & locale. Pure HTTP, no browser. $1/1k flat, JSON or CSV out.",
        "version": "0.0",
        "x-build-id": "jXAlUGwcJLTW7G13U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~agoda-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-agoda-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/memo23~agoda-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-agoda-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/memo23~agoda-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-agoda-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",
                "properties": {
                    "startUrls": {
                        "title": "Hotel URLs",
                        "type": "array",
                        "description": "Optional. Paste one or more Agoda hotel-page URLs (e.g. https://www.agoda.com/alkhayma-medina/hotel/marrakech-ma.html) to scrape those exact hotels. When provided, the destination/date search below is ignored and each URL is returned as a full priced row — name, nightly price, star rating, review score & count, location, amenities, image — resolved to its Agoda propertyId automatically. Combine with 'Include detailed review scores' for per-category sub-scores and description.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "location": {
                        "title": "Destination",
                        "type": "string",
                        "description": "City or destination to search, e.g. London, Bangkok, New York. Resolved to Agoda's cityId automatically. Defaults to London. (Ignored when Hotel URLs are provided above.)"
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Check-in date. Leave empty to default to ~30 days from today (so the Actor always runs out of the box)."
                    },
                    "checkOut": {
                        "title": "Check-out date (optional)",
                        "type": "string",
                        "description": "Check-out date. If set, the number of nights is derived from it. Otherwise 'Nights' is used."
                    },
                    "nights": {
                        "title": "Nights",
                        "minimum": 1,
                        "maximum": 28,
                        "type": "integer",
                        "description": "Length of stay in nights (ignored if a check-out date is given). Default 1.",
                        "default": 1
                    },
                    "rooms": {
                        "title": "Rooms",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of rooms.",
                        "default": 1
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 2
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of child guests.",
                        "default": 0
                    },
                    "childAges": {
                        "title": "Child ages (optional)",
                        "type": "array",
                        "description": "Ages of the children, e.g. [5, 9]. Only used when Children > 0.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortField": {
                        "title": "Sort by",
                        "enum": [
                            "Ranking",
                            "Price",
                            "Recommended",
                            "Review",
                            "Distance"
                        ],
                        "type": "string",
                        "description": "How to sort the hotel results.",
                        "default": "Ranking"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "ISO 4217 currency code for prices, e.g. USD, EUR, GBP, THB.",
                        "default": "USD"
                    },
                    "market": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Site locale, e.g. en-gb, en-us, de-de. Affects language and some pricing.",
                        "default": "en-gb"
                    },
                    "maxItems": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Maximum number of hotels to return.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include detailed review scores & description",
                        "type": "boolean",
                        "description": "For each hotel, fetch its detail page to add per-category review sub-scores (cleanliness, location, staff, value…) with city averages, score distribution, 30-day review trend, description, and AI review highlights. Adds one extra request per hotel, so runs are slower.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Guest reviews per hotel",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Scrape up to this many individual guest reviews per hotel — review text, title, rating, traveler type, room type, length of stay, reviewer country, the hotel's response, and any review photos. 0 = skip reviews (default). Works in both modes; paginates extra requests per hotel, so large values × many hotels run slower.",
                        "default": 0
                    },
                    "reviewsSort": {
                        "title": "Reviews sort order",
                        "enum": [
                            "Most recent",
                            "Highest rated",
                            "Lowest rated",
                            "Most helpful"
                        ],
                        "type": "string",
                        "description": "Order in which guest reviews are scraped (only used when 'Guest reviews per hotel' is above 0).",
                        "default": "Most recent"
                    },
                    "starRatings": {
                        "title": "Star ratings",
                        "type": "array",
                        "description": "Keep only hotels with these official star ratings. Empty = any.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        }
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Keep only these accommodation types (matched against each hotel's type). Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hotel",
                                "apartment",
                                "hostel",
                                "resort",
                                "villa",
                                "guest",
                                "homestay",
                                "bungalow",
                                "vacation"
                            ],
                            "enumTitles": [
                                "Hotel",
                                "Apartment",
                                "Hostel",
                                "Resort",
                                "Villa",
                                "Guest house",
                                "Homestay",
                                "Bungalow",
                                "Vacation home"
                            ]
                        }
                    },
                    "priceMin": {
                        "title": "Min price per night",
                        "type": "integer",
                        "description": "Only hotels with a nightly price at or above this (in the selected currency). Empty = no minimum."
                    },
                    "priceMax": {
                        "title": "Max price per night",
                        "type": "integer",
                        "description": "Only hotels with a nightly price at or below this (in the selected currency). Empty = no maximum."
                    },
                    "minReviewScore": {
                        "title": "Min review score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Only hotels with a guest review score at or above this (Agoda scale 0-10). Empty = no minimum."
                    },
                    "maxReviewScore": {
                        "title": "Max review score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Only hotels with a guest review score at or below this (Agoda scale 0-10). Empty = no maximum."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended (and on by default).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
