# Agoda Hotel Scraper — Prices, Reviews & Amenities | $5/1K (`bovi/agoda-scraper`) Actor

Scrape **Agoda** hotel property pages to extract **hotel name, star rating, review score, room types, amenities, coordinates, and images**. Input: property URLs or hotel IDs. Uses Agoda's internal **Cronos JSON API** — structural, no CSS classes, robust to HTML changes.

- **URL**: https://apify.com/bovi/agoda-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Travel, AI, MCP servers
- **Stats:** 55 total users, 19 monthly users, 99.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.85 / 1,000 hotels

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?

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

## How to integrate an Actor?

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

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Agoda Hotel Scraper — Rooms, Reviews & Amenities | from $2/1K | No Login

**For travel tech teams, hotel chains, OTA intelligence platforms, and hospitality researchers** that need deep Agoda property data — rooms, amenities, sub-scores — without managing browser infrastructure.

**$2.00 per 1,000 hotels. Guest review comments (optional) add $0.50/1,000 reviews.** No login, no proxy required for standard volumes — Agoda's internal Cronos API needs no special access.

**Pricing example:** 50 hotels = **$0.10**. 500 hotels = **$1.00**. 500 hotels + 10 reviews each (5,000 reviews) = **$1.00 + $2.50 = $3.50** total.

**Standout feature: 6-sub-score `category_scores`** — cleanliness, facilities, location, roomComfort, service, valueForMoney. Most competitors return only the overall rating.

| Scraper | Price / 1k | Score distribution? | Per-room bed/size/view? | `parse_confidence`? |
|---|---|---|---|---|
| **This actor** | **$2** hotel + $0.50 reviews | **Yes** | **Yes** | **Yes** |
| huggable\_quote/fast-agoda-hotel-scraper | from $3.50 | No | No | No |
| knagymate/fast-agoda-scraper | $5.00 | No | No | No (search-page, Cloudflare-exposed) |

Scrape **Agoda hotel data** at the field-completeness level competitors charge double for — and with a reliability guarantee none of them publish. Extract **hotel name, star rating, guest review score, per-category sub-scores, room types with bed/size/view, full amenity lists, nearby attractions, coordinates, and every photo URL** for any Agoda property. Search by **hotel name**, paste **property URLs**, or feed **hotel IDs** — your choice. **Pay per hotel result.**

Built on Agoda's internal **Cronos JSON API** — the same structured endpoint Agoda's own website calls. No fragile CSS-class scraping, no HTML parsing for data fields. Every record carries a `parse_confidence` score so you know instantly if anything drifted.

***

### Why This Agoda Scraper Wins

Most Agoda scrapers parse the rendered HTML or scrape the protected search page — both break the moment Agoda reskins or tightens access controls. This actor takes a different path:

1. It resolves your input to a numeric **hotel ID** (from a name search, a URL, or directly).
2. It calls Agoda's **Cronos BelowFold JSON API** — one GET request returning the entire hotel record as structured JSON.
3. It maps that JSON with a **dual-path parser**: a primary path on the known keys, and a **structural fallback** that finds fields by shape (not by fixed location) if Agoda re-nests its payload.

| Endpoint | Access | Status |
|----------|----------|--------|
| Property page HTML | None detected | 200 OK confirmed |
| BelowFold JSON API | None detected | 200 OK confirmed |
| Suggest (name search) API | None detected | 200 OK confirmed |
| Review comments API | None detected | 200 OK confirmed |
| Search results page | Cloudflare | Not used (we don't need it) |

If Agoda ever changes its JSON shape, you don't get silent empty rows — you get a record with a **lowered `parse_confidence` and machine-readable `warnings`** telling you exactly which field fell back. That is the difference between a scraper you can trust in production and one you have to babysit.

***

### Why this beats the alternatives

The Agoda field on the Apify Store splits into two kinds of scraper, and this actor beats both:

- **Search-page scrapers** like `knagymate/fast-agoda-scraper` ($5/1k) scrape the one Agoda surface that *is* protected, and return a thin record (name, price, rating, location) — **no rooms, no amenities, no score distribution, no confidence**. When Agoda tightens access controls, they stop. We never touch that page: we go straight to the Cronos **BelowFold JSON API** (no special access, confirmed 200 OK), and rotate IP + retry on the rare block.
- **Detail scrapers** like `huggable_quote/fast-agoda-hotel-scraper` (from $3.50/1k, "22+ fields") are the strong incumbent — they *do* return per-category `reviewCategoryScores` and nearby `placesOfInterest` (so we don't pretend to uniquely own those). But their docs confirm **no score distribution, no per-room breakdown, no parse-confidence**.

| Capability | This actor | huggable\_quote detail scraper | knagymate search scraper |
|---|---|---|---|
| Avoids Cloudflare search page | **Yes** (Cronos JSON API) | Yes (detail API) | **No** (scrapes search page) |
| Per-category sub-scores | Yes (6) | Yes (5) | No |
| **`score_distribution`** (counts per band) | **Yes** | No | No |
| **Per-room `bed` / `size` / `view`** | **Yes** | No | No |
| `amenity_groups` (grouped) | Yes | Flat list | No |
| `nearby_essentials` w/ `distance_km` | Yes | Attractions only | No |
| **`parse_confidence` + drift `warnings`** | **Yes** | No | No |
| Base price / 1k | **$2** | from $3.50 | $5 |

**The one-sentence edge:** the Agoda scraper that skips the Cloudflare search page entirely, adds the **score distribution** and **per-room (bed/size/view)** breakdown the best competitor omits, and tells you — via `parse_confidence` — the moment Agoda's JSON drifts, at **$2/1k** (vs $3.50–$5). Full breakdown in [`COMPETITIVE_EDGE.md`](./COMPETITIVE_EDGE.md).

***

### Three Ways to Input

#### Option A — search by hotel name (no URL hunting)

```json
{ "searchTerms": ["The Peninsula Bangkok", "Marina Bay Sands"] }
```

Each term is resolved through Agoda's suggest API to the matching hotel ID, then scraped. Best with a specific hotel name; broad city names return only the few top properties Agoda surfaces.

#### Option B — property URLs

```json
{
  "propertyUrls": [
    "https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html"
  ]
}
```

#### Option C — hotel IDs

```json
{ "hotelIds": [10715, 197181] }
```

Mix and match all three in one run. Add `"includeReviews": true` and `"reviewsPerHotel": 20` to pull guest comments.

***

### Output Schema — Per Hotel

| Field | Type | Description |
|-------|------|-------------|
| `hotel_id` | integer | Agoda internal hotel ID |
| `hotel_name` | string | Hotel name |
| `former_name` | string | Previous name, if any |
| `accommodation_type` | string | "Hotel", "Apartment", "Villa", etc. |
| `address` | string | Full address |
| `city` / `country` / `area_name` | string | Location parts |
| `postal_code` | string | Postal/ZIP code |
| `location_highlight` | string | e.g. "800 meters from city center" |
| `star_rating` | float | Official star rating (1–5) |
| `review_score` | float | Agoda guest score (0–10) |
| `review_count` | integer | Number of verified reviews |
| `review_text` | string | Score label ("Exceptional", "Superb") |
| `category_scores` | object | Per-category 0–10: cleanliness, facilities, location, roomComfort, service, valueForMoney |
| `score_distribution` | object | Review counts per band (9+, 8–9, …) |
| `awards` | string | Awards & accolades, if listed |
| `price` / `currency` | float / string | Cheapest nightly rate for your `checkIn` date (null if no date given or sold out) |
| `rooms_available` / `offer_count` | bool / int | Whether any room is bookable for the dates, and how many priced offers were found |
| `room_offers` | list | Per-room offers: `room_name`, `price_per_night`, `crossed_out` (discount), `currency` |
| `check_in` / `length_of_stay` | string / int | The date window you requested, echoed back |
| `room_types` | array | Room type names |
| `rooms` | array | Rich per-room objects: name, bed, size, view, features, image\_count, thumbnail |
| `amenities` | array | Flat, de-duplicated amenity list |
| `amenity_groups` | object | Amenities grouped by category |
| `highlights` | array | Notable highlights |
| `nearby_attractions` | array | Attractions with distance text |
| `nearby_essentials` | array | Airports/transport with `distance_km` |
| `check_in_time` / `check_out_time` | string | When available |
| `description` | string | Full property overview |
| `image_url` | string | Hero image (CDN) |
| `image_count` | integer | Total photos available |
| `all_images` | array | Every photo URL |
| `lat` / `lng` | float | Coordinates |
| `property_url` | string | Agoda property page URL |
| `parse_confidence` | float | 0.0–1.0 structural parse-quality score |
| `warnings` | array | Machine-readable drift signals |
| `scraped_at` | string | ISO-8601 UTC timestamp |
| `reviews` | array | Guest comments (when `includeReviews=true`) |

#### Review record fields (when `includeReviews=true`)

`review_id`, `rating`, `title`, `comment`, `positives`, `negatives`, `check_in_month`, `review_date`, `reviewer_type`, `reviewer_country`, `room_type`, `stay_length`.

***

### Sample output

```json
{
  "hotel_id": 10715,
  "hotel_name": "The Peninsula Bangkok",
  "former_name": null,
  "accommodation_type": "Hotel",
  "address": "Siam Chaophraya Holdings, 333 Charoennakorn Road, Bangkok Riverside, Bangkok, Thailand, 10600",
  "city": "Bangkok",
  "country": "Thailand",
  "area_name": "Bangkok Riverside",
  "postal_code": "10600",
  "location_highlight": "800 meters from city center",
  "star_rating": 5,
  "review_score": 9.2,
  "review_count": 5140,
  "review_text": "Exceptional",
  "category_scores": {
    "cleanliness": 9.6,
    "facilities": 9.4,
    "location": 9,
    "roomComfort": 9.3,
    "staffPerformance": 9.5,
    "valueForMoney": 9
  },
  "score_distribution": {
    "exceptional": 2020,
    "excellent": 400,
    "very_good": 89,
    "good": 60,
    "below_expectation": 58
  },
  "awards": null,
  "price": null,
  "currency": null,
  "rooms_available": null,
  "offer_count": null,
  "room_offers": [],
  "check_in": null,
  "length_of_stay": null,
  "room_types": [
    "Deluxe Twin Room",
    "The Grand Terrace Suite",
    "King Room with Balcony",
    "Grand Deluxe King Room with Balcony",
    "Deluxe King Suite"
  ],
  "rooms": [
    {
      "name": "Deluxe Twin Room",
      "room_id": 7619240,
      "bed": "2 single beds",
      "size": "Room size: 45 m²/484 ft²",
      "view": "Sea view",
      "features": [
        "Room size: 45 m²/484 ft²",
        "Sea view",
        "2 single beds"
      ],
      "image_count": 16,
      "thumbnail": "https://q-xx.bstatic.com/xdata/images/hotel/max500/668438342.jpg?k=cf470c4280e289e0fdad068e3f648ac416a80bc2a1b8dfe6b091f%E2%80%A6"
    },
    {
      "name": "The Grand Terrace Suite",
      "room_id": 347399195,
      "bed": "1 king bed and 2 queen beds",
      "size": "Room size: 240 m²/2583 ft²",
      "view": "River view",
      "features": [
        "Room size: 240 m²/2583 ft²",
        "River view",
        "1 king bed and 2 queen beds"
      ],
      "image_count": 11,
      "thumbnail": "https://pix8.agoda.net/property/10715/873421915/03a3d7f1dba1b7894b42a428975199fd.jpeg?ce=0"
    }
  ],
  "amenities": [
    "English",
    "Chinese [Mandarin]",
    "Filipino",
    "French",
    "German",
    "Japanese",
    "Korean",
    "Spanish"
  ],
  "amenity_groups": {
    "Languages spoken": [
      "English",
      "Chinese [Mandarin]",
      "Filipino"
    ],
    "Accessibility": [
      "Wheelchair accessible"
    ]
  },
  "highlights": [
    "450 meters to public transportation",
    "Sights and Monuments",
    "Wat Phra Chetuphon",
    "Restaurants"
  ],
  "nearby_attractions": [
    "Hua Lamphong Railway Station - 1.9 km from property",
    "Yaowarat Road (Bangkok Chinatown) - 1.93 km from property",
    "Chulalongkorn University - 2.84 km from property"
  ],
  "nearby_essentials": [
    {
      "category": "Airports",
      "name": "Don Mueang International Airport (DMK)",
      "distance_km": 23.43,
      "distance_text": "23.43 km"
    },
    {
      "category": "Airports",
      "name": "Suvarnabhumi Airport (BKK)",
      "distance_km": 26.1,
      "distance_text": "26.1 km"
    },
    {
      "category": "Public transportation",
      "name": "Charoen Nakhon BTS Station",
      "distance_km": 0.45,
      "distance_text": "450 m"
    }
  ],
  "check_in_time": "Check-in time",
  "check_out_time": "Check-out time",
  "description": "<b>Experience Luxury and Elegance at <b>The Peninsula Bangkok</b></b><br><br>Welcome to <b>The Peninsula Bangkok</b>, a …",
  "image_url": "https://pix8.agoda.net/hotelImages/10715/0/c7d902af89c86df40c58bc0298e51a63.jpeg?ce=3&s=1024x768",
  "image_count": 88,
  "all_images": [
    "https://pix8.agoda.net/hotelImages/10715/0/c7d902af89c86df40c58bc0298e51a63.jpeg?ce=3&s=1024x768",
    "https://q-xx.bstatic.com/xdata/images/hotel/max1024x768/434993345.jpg?k=7a729dd2f098e2ef7dbd892a06eb154ffdc2b4a58fda9293%E2%80%A6",
    "https://pix8.agoda.net/property/10715/1274939685/6a4324590912a5e45984c42c5cc05f12.jpeg?ce=3&s=1024x768"
  ],
  "lat": 13.7230730056763,
  "lng": 100.510955810547,
  "property_url": null,
  "parse_confidence": 1,
  "warnings": [],
  "scraped_at": "2026-06-22T23:00:28.964406+00:00"
}
```

***

### Use Cases

#### Competitive hotel benchmarking

Compare star rating, overall score, and **per-category sub-scores** (cleanliness vs service vs value) across rival properties in one city. The `category_scores` field surfaces exactly where a competitor wins or loses — data most scrapers omit entirely.

#### Travel app & map enrichment

Hydrate hotel listings with amenities, room configurations, `nearby_attractions`, `nearby_essentials` (airport distance in km), `lat`/`lng`, and the full `all_images` gallery.

#### Reputation & sentiment monitoring

Track `review_score`, `review_count`, and `score_distribution` over time, and pull `includeReviews=true` to feed `comment`/`positives`/`negatives` into sentiment or theme-extraction pipelines.

#### Hospitality market research

Build datasets by city, country, or accommodation type. Filter on star rating, score, amenities, or room attributes (bed type, room size, view).

***

### Notes on Pricing Data

Pricing is **date-aware**: supply a `checkIn` date (plus optional `lengthOfStay`, `adults`, `rooms`) and the actor fetches Agoda's live room grid for that window — filling `price` (cheapest nightly rate), `currency`, `rooms_available`, `offer_count` and a full `room_offers` list. Omit `checkIn` and you get dateless hotel metadata only, with `price` honestly `null` (never an invented `0`). A sold-out date returns `rooms_available: false`, not a parse error.

***

### Proxy

Defaults to **Apify Residential** proxy (`useApifyProxy: true`, groups `["RESIDENTIAL"]`) — recommended for production scale. The JSON API works from datacenter IPs in testing, but residential ensures reliability at volume. On a block, the actor **rotates to a fresh exit IP and retries with backoff** automatically. Proxy usage is billed to the run owner.

***

### Pricing

Pay per hotel result successfully scraped (**$5.00/1k**, billed as `apify-default-dataset-item`). Reviews and live room offers are included in the hotel row when enabled on paid runs; there is no separate review event. Free-plan previews return up to 5 hotel rows and skip review comments/live price lookup to keep evaluation runs small. **Failed or blocked fetches are never charged because no dataset row is pushed.**

***

### FAQ

**Does this work outside Asia?** Yes. Agoda lists hotels globally; the API returns data for any indexed property.

**How do I find a property URL?** Open any hotel on agoda.com and copy the browser URL — or just use `searchTerms` with the hotel name.

**Is pricing real-time?** Yes — supply a `checkIn` date and the actor reads Agoda's live room grid for that window, returning the cheapest nightly rate plus every priced room offer. Without a date you get dateless metadata only.

**What is `parse_confidence`?** A 0.0–1.0 score per record. 1.0 means every expected field resolved on the primary path. A lower score with `warnings` means Agoda's structure drifted and a fallback path was used — your early-warning signal.

***

### parse\_confidence trust score

Every record carries a `parse_confidence` score (0.0–1.0) and a `warnings` list. The Cronos API dual-path parser flags drift loudly instead of returning silent empty rows.

### Use with AI agents (MCP)

This actor is available as an MCP tool for Claude, GPT-4o, or any MCP-compatible agent.

Config: https://mcp.apify.com/?tools=bovi/agoda-scraper

*Not affiliated with Agoda. Data is retrieved from publicly accessible Agoda property pages and internal APIs.*

### Integrations

Built for travel-tech teams and OTA intelligence platforms benchmarking hotel rates, amenities, and per-category guest scores — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Airbnb Scraper](https://apify.com/bovi/airbnb-scraper)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

# Actor input Schema

## `searchTerms` (type: `array`):

Free-text hotel names or destinations to look up — no URL hunting needed. Each term is resolved via Agoda's suggest API to one or more hotel IDs, then scraped. Works best with a specific hotel name (e.g. "Peninsula Bangkok", "Marina Bay Sands"). Broad city names (e.g. "Bangkok") return only the few top properties Agoda surfaces in its suggest box — for full city coverage, supply propertyUrls or hotelIds. Combine freely with the other inputs.

## `propertyUrls` (type: `array`):

List of Agoda hotel property page URLs to scrape. Each URL must be the full Agoda property page, e.g. https://www.agoda.com/the-peninsula-bangkok/hotel/bangkok-th.html. The actor extracts the hotel ID from the page and calls the internal JSON API — no HTML parsing needed. Find URLs by searching Agoda normally and copying the property link.

## `hotelIds` (type: `array`):

Alternative input: list of Agoda numeric hotel IDs. Each ID is the integer found in the Agoda Cronos API, e.g. \[10715, 197181]. Use this when you already know the hotel IDs from a previous run or from the Agoda URL structure. Example: \[10715]

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

Optional check-in date as YYYY-MM-DD (e.g. 2026-12-28). When set, the actor fetches the LIVE date-aware room grid and fills price (cheapest nightly rate), currency, rooms\_available, offer\_count and a per-room room\_offers list. Leave empty for dateless hotel metadata only (no prices). Combine with lengthOfStay, adults, rooms.

## `lengthOfStay` (type: `integer`):

Number of nights for the live-price lookup (only used when checkIn is set). Range 1–30. Default 1.

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

Number of adult guests for the live-price lookup (only used when checkIn is set). Range 1–20. Default 2.

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

Number of rooms for the live-price lookup (only used when checkIn is set). Range 1–10. Default 1.

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

When enabled, fetches up to reviewsPerHotel individual review comments for each hotel via the Agoda reviews API. Each review adds an extra API call. Reviews include reviewer rating, title, comment text, and check-in date. Default: false.

## `reviewsPerHotel` (type: `integer`):

Maximum number of review comments to fetch per hotel (only applies when includeReviews is enabled). Reviews are sorted by most recent. Range: 1–50. Default: 10.

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

Maximum total hotel records to return across all inputs. 0 = unlimited. Use to control cost — each hotel is one PPE charge regardless of how many reviews are fetched.

## `requestDelay` (type: `number`):

Seconds to wait between consecutive property fetches. Default 1.5s is polite and reduces ban risk. Increase for large batches.

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

Proxy settings. Default: Apify RESIDENTIAL proxy (recommended for production scale). Property pages and JSON API calls work from datacenter IPs in testing, but RESIDENTIAL ensures reliability at volume. Set useApifyProxy:true with groups:\["RESIDENTIAL"].

## Actor input object example

```json
{
  "searchTerms": [
    "The Peninsula Bangkok"
  ],
  "lengthOfStay": 1,
  "adults": 2,
  "rooms": 1,
  "includeReviews": false,
  "reviewsPerHotel": 10,
  "maxItems": 0,
  "requestDelay": 1.5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Agoda Scraper records (hotel\_name, accommodation\_type, city, country, star\_rating, review\_score, review\_count, price, currency, rooms\_available, offer\_count, check\_in, property\_url, scraped\_at, parse\_confidence).

# 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 = {
    "searchTerms": [
        "The Peninsula Bangkok"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/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 = { "searchTerms": ["The Peninsula Bangkok"] }

# Run the Actor and wait for it to finish
run = client.actor("bovi/agoda-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 '{
  "searchTerms": [
    "The Peninsula Bangkok"
  ]
}' |
apify call bovi/agoda-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bovi/agoda-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/o3FbcjAbRO9XX5Agi/builds/Ne12lQw5YkSBkYrhn/openapi.json