# Tripadvisor Review Scraper (`scraper-engine/tripadvisor-review-scraper`) Actor

Scrape Tripadvisor reviews from any hotel, restaurant, or attraction. This actor extracts reviewer names, ratings, dates, comments, and location details. Perfect for sentiment analysis, competitor tracking, and travel market research.

- **URL**: https://apify.com/scraper-engine/tripadvisor-review-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Travel, Automation, Lead generation
- **Stats:** 30 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

### TripAdvisor Review Scraper — Ratings, Text and Reviewer Profiles

Extract TripAdvisor reviews as structured JSON: review text, star rating, subratings, travel date, reviewer profile, owner responses, photos, and place metadata — no HTML parsing required. Works on hotels, restaurants and attractions. Point it at a TripAdvisor URL, a place name, or a keyword and it returns typed, ready-to-use rows. Start a run from the Apify Console or the API and watch reviews land in your dataset in real time.

### 🏨 What is TripAdvisor Review Scraper?

TripAdvisor Review Scraper is an Apify Actor that pulls reviews from TripAdvisor **hotel, restaurant and attraction pages** (`Hotel_Review-*`, `Restaurant_Review-*`, `Attraction_Review-*` URLs) and returns each review as a JSON row — text, rating, subratings, trip details, reviewer profile, and the place's own metadata. No TripAdvisor account or login is required — the Actor reads the same public review pages any visitor sees. It's built for hospitality teams, market researchers, and developers who need review data in a pipeline rather than a browser tab.

### 🔓 What TripAdvisor review data is publicly available to scrape?

Everything a TripAdvisor visitor can see on a place's review page is public — no login is required to read reviews, ratings, or place details. What's gated sits behind a TripAdvisor account for *writing*, not reading.

| Data Category | Publicly Available | Restricted (TripAdvisor account required) |
| --- | --- | --- |
| Review text, title, star rating | Yes | |
| Subratings (Value, Location, Cleanliness, Service, Sleep Quality...) | Yes | |
| Reviewer display name, username, home location, contribution count | Yes | |
| Owner / management responses | Yes | |
| Place name, place type, canonical TripAdvisor URL, total review count | Yes | |
| Review photos | Yes | |
| Writing a review or voting a review "helpful" | | Login required |
| Reviewer's private contact details (email, phone) | | Not published by TripAdvisor at all, with or without login |

TripAdvisor Review Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### 📋 What data can I extract with TripAdvisor Review Scraper?

Every review row carries the fields below, read directly from the row-building code in `src/main.py` — not just the columns shown in the default dataset view.

#### 📝 Review identity and content fields

| Field | Description |
| --- | --- |
| `id` | TripAdvisor's internal review ID |
| `url` | Direct link to the review on TripAdvisor |
| `title` | Review headline |
| `text` | Full written review body |
| `lang` | Language code the review was written in |
| `locationId` | TripAdvisor location ID for the place |
| `publishedDate` | Date the review was published |
| `travelDate` | Month/year of the reviewer's stay (`YYYY-MM`) |
| `tripType` | Trip context TripAdvisor assigns (e.g. `FAMILY`, `COUPLES`, `BUSINESS`) |
| `roomTip` | Reviewer's tip for future guests, if one was given (`null` otherwise) |

#### ⭐ Ratings and engagement fields

| Field | Description |
| --- | --- |
| `rating` | Overall star rating, 1–5 |
| `helpfulVotes` | Helpful-vote count on the review itself |
| `subratings` | Array of `{name, value}` category ratings (Value, Rooms, Location, Cleanliness, Service, Sleep Quality — categories vary by place type; empty when the reviewer rated no categories) |

#### 🧩 Nested objects: reviewer, owner response, photos, and place info

| Field | Description |
| --- | --- |
| `user` | Reviewer profile object — `userId`, `name`, `username`, `isVerified`, `userLocation`, `avatar`, `link`, `contributions.totalContributions` and `contributions.helpfulVotes`. `null` when `scrapeReviewerInfo` is disabled |
| `ownerResponse` | Management's reply object — `id`, `text`, `lang`, `publishedDate`, `responder`, `connectionToSubject`. `null` when the property never responded |
| `photos` | Array of reviewer-submitted photos — `id`, `url`, `caption` |
| `placeInfo` | Place metadata — `id`, `name`, `webUrl`, `placeType` (`ACCOMMODATION`, `EATERY`, `ATTRACTION`, `ACTIVITY`) and `numberOfReviews` (the place's full review count on TripAdvisor, unaffected by this run's language filter). Every value is read from TripAdvisor's review API — fields TripAdvisor does not expose on this data source (street address, geo-coordinates, rating histogram) are deliberately absent rather than filled with placeholders, and `publishPlatform` / `accommodationCategory` are dropped because TripAdvisor returns a constant for them rather than a real value |
| `scrapedAt` | ISO-8601 UTC timestamp of when the row was collected |

#### 🤖 Add-on: Need additional TripAdvisor data?

This Actor is scoped to reviews. For place discovery beyond reviews, or for Google-side review data on the same properties, pair it with **Google Maps Extractor** in the same account. For the accommodation-listing side of a trip (not reviews), **Airbnb Rooms URLs Scraper** covers Airbnb host portfolios.

### 🔌 How does TripAdvisor Review Scraper differ from the official TripAdvisor Content API?

TripAdvisor publishes an official Content API, but its Location Reviews endpoint returns only the 5 most recent reviews per location — nowhere near enough for trend analysis or bulk research. TripAdvisor Review Scraper returns up to 10,000 reviews per place, in the order you choose, with the full reviewer profile attached.

| Feature | TripAdvisor Content API | TripAdvisor Review Scraper |
| --- | --- | --- |
| Reviews per location | Up to 5 most recent (as documented on the API's ReadMe portal, checked 2026-08-04) | Up to 10,000 per place per run |
| Historical / oldest reviews | Not supported — most-recent only | `sortOrder: "oldest"` available |
| Reviewer profile fields | Not documented in the public reference | Full profile (name, username, location, avatar, contributions) when `scrapeReviewerInfo` is enabled |
| Rating filtering | Not documented | Filter by star rating or positive/negative/average via `reviewRatings` |
| Rate limit | Up to 50 calls per second (as documented, checked 2026-08-04) | No published call-rate cap — bound by TripAdvisor's own anti-bot response during a run |
| Setup | TripAdvisor developer account, billing details, and a pay-as-you-go budget | Apify account only — no TripAdvisor account needed |

Use the official Content API if 5 recent reviews per property is enough and you already have TripAdvisor developer credentials. Use TripAdvisor Review Scraper when you need deep review history, reviewer profiles, or rating-filtered datasets without opening a TripAdvisor developer account.

### ▶️ How to use TripAdvisor Review Scraper

1. Open the Actor's page on the Apify Store and click **Try for free** (or find it in your Apify Console under Actors).
2. Add at least one entry to the required **`startUrls`** field — a direct TripAdvisor review URL, a place name, or a keyword.
3. Optionally set **`maxComments`**, **`sortOrder`**, **`reviewsLanguages`**, **`reviewRatings`**, and **`scrapeReviewerInfo`**.
4. Click **Start**. Reviews are pushed to the dataset one at a time as they're collected, so results appear during the run.
5. Download results as JSON, CSV, Excel, XML, or RSS from the dataset toolbar, or pull them with `apify_client` / a webhook once the run finishes.

#### 🏨 How to scale to bulk review extraction

`startUrls` is an array — add as many TripAdvisor URLs, place names, or keywords as you want in one run, and the Actor works through them one place at a time, applying the same `maxComments`, sort, language, and rating settings to each. There's no separate "bulk mode" to enable; a longer list is the bulk method.

### 💡 What can you do with TripAdvisor review data?

- 🏨 **Revenue managers** monitoring guest sentiment use `rating` and `subratings` to track category-level trends (cleanliness, service, value) across a property over time.
- 📊 **Market researchers and analysts** pull `text`, `rating`, `tripType`, and `travelDate` into a BI dashboard to compare guest experience by season or traveler segment.
- 🕵️ **Competitive intelligence teams** compare `rating` distributions and `subratings` across competitor properties to benchmark positioning.
- 💬 **Customer experience teams** filter on `ownerResponse` to find reviews a property has, or hasn't, responded to.
- 🤖 **AI engineers** feed the `text` field into an LLM summarization or sentiment pipeline, using `placeInfo` and `subratings` as structured grounding context — no scraping or HTML cleanup needed before it reaches the model.

### 🛡️ How does TripAdvisor Review Scraper handle rate limits and blocking?

TripAdvisor's HTML pages sit behind DataDome bot protection, which answers a server-side HTTP client with a 403 challenge stub no matter which proxy tier it comes from. The Actor sidesteps that entirely: it never fetches an HTML review page. Reviews come from TripAdvisor's own review API (`/data/graphql/ids`), which is not behind DataDome and answers a plain HTTP request with the same review objects the site renders. That endpoint was verified working on direct, datacenter and residential egress, so `proxyConfiguration` is about spreading request volume rather than getting past a block.

Failed or non-200 requests to TripAdvisor's GraphQL endpoint are retried up to 3 times with a short delay before the Actor gives up on that page and moves on. TripAdvisor's review API only reliably accepts its default `SERVER_DETERMINED` sort; if it rejects `sortOrder: "oldest"` or `"rating"` mid-run, the Actor automatically falls back to the default order and keeps collecting rather than failing the run.

⚠️ TripAdvisor's own pagination caps each request at 20 reviews per page regardless of `maxComments`, and the Actor enforces a hard safety ceiling of 10,000 reviews per place even if you request more.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `startUrls` | Yes | array | Direct TripAdvisor review URLs (`Hotel_Review`, `Restaurant_Review`, `Attraction_Review`, `AttractionProductReview`, `VacationRentalReview`, `ShowUserReviews`), place names, or keywords. Mix and match freely. | `["https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html"]` |
| `maxComments` | No | integer | Maximum reviews to collect per URL. Default `10`, minimum `1`, maximum `10000`. | `100` |
| `sortOrder` | No | string | Order reviews are fetched in. Enum: `newest` (default), `oldest`, `relevant`, `rating`. `relevant` currently returns the same order as `newest` — TripAdvisor does not expose a distinct relevance ranking on this data source. | `"newest"` |
| `reviewsLanguages` | No | string | Language to filter reviews by. Default `"English"`. Enum: `ALL_REVIEW_LANGUAGES` plus 29 named languages (Spanish, French, German, Italian, Portuguese, Dutch, Russian, Japanese, Korean, Chinese Simplified/Traditional, Arabic, Turkish, Hebrew, Swedish, Norwegian, Danish, Finnish, Polish, Czech, Hungarian, Romanian, Greek, Thai, Vietnamese, Indonesian, Malay, Hindi). | `"English"` |
| `reviewRatings` | No | string | Star-rating filter applied after fetching. Default `"ALL_REVIEW_RATINGS"`. Enum: `ALL_REVIEW_RATINGS`, `POSITIVE` (4–5★), `NEGATIVE` (1–2★), `AVERAGE` (3★), or a specific value `"5"`, `"4"`, `"3"`, `"2"`, `"1"`. | `"ALL_REVIEW_RATINGS"` |
| `scrapeReviewerInfo` | No | boolean | Include the full reviewer profile object. Default `true`. When `false`, the `user` field is `null` in every row. | `true` |
| `reviewQueryId` | No | string | Advanced: pin a specific TripAdvisor persisted-query id instead of letting the Actor resolve one. Leave empty unless you know you need it. | `"ef3cb4f569f27e43"` |
| `proxyConfiguration` | No | object | Apify Proxy configuration. Defaults to Residential, which gives the most rate-limit headroom; datacenter and no-proxy both work too. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

#### Example input

```json
{
  "startUrls": [
    "https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html",
    "luxury hotel New York"
  ],
  "maxComments": 200,
  "sortOrder": "newest",
  "reviewsLanguages": "English",
  "reviewRatings": "ALL_REVIEW_RATINGS",
  "scrapeReviewerInfo": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### ⬆️ Output

Each collected review is pushed to the Apify dataset as one typed JSON row, with a consistent schema across runs. Export as JSON, CSV, Excel, XML, or RSS from the dataset toolbar, or read it via API/`apify_client`. The Actor is billed pay-per-event on the `row_result` event — one charge per review row actually pushed to the dataset. Reviews filtered out post-fetch by `reviewRatings`, or rows that fail to parse, are never pushed and never charged.

#### Example output

```json
{
  "id": "1074754117",
  "url": "https://www.tripadvisor.com/ShowUserReviews-g60763-d208453-r1074754117-Hilton_New_York_Times_Square-New_York_City_New_York.html",
  "title": "great stay and so relaxing",
  "lang": "en",
  "locationId": "208453",
  "publishedDate": "2026-08-24",
  "rating": 5,
  "helpfulVotes": 0,
  "text": "The location was fabulous - so convenient to the subway and theatre.  The service was always friendly.  The rooms were clean, with a great view and no noise from the street!!!  The room was so comfortable I even slept through the night.  The room rate was a bargain considering the location, room, noise level and service.  We really enjoyed our stay and will definitely come again and recommend the hotel to others.",
  "roomTip": null,
  "travelDate": "2026-08",
  "tripType": "FAMILY",
  "user": {
    "userId": "BC7A336921ADD01F88AFB392620494E8",
    "name": "Passport503119",
    "username": "Passport503119",
    "isVerified": false,
    "contributions": {
      "totalContributions": 1,
      "helpfulVotes": 0
    },
    "userLocation": null,
    "avatar": "https://dynamic-media-cdn.tripadvisor.com/media/photo-o/1a/f6/f1/79/default-avatar-2020-21.jpg?w=100&h=100&s=1",
    "link": "https://www.tripadvisor.com/Profile/Passport503119"
  },
  "ownerResponse": {
    "id": "1075167008",
    "text": "Thank you for sharing such a wonderful review and recommendation with us! We're thrilled to have met the mark in terms of both convenience and comfort. Placing our guests in the center of the action, while maintaining a quiet atmosphere, is something we're very proud to offer here at Hilton Times Square. We sincerely appreciate your kind recognition and hope to welcome you back for another stellar stay in the future!",
    "lang": "en",
    "publishedDate": "2026-08-27",
    "responder": "Front Desk",
    "connectionToSubject": "General Manager"
  },
  "subratings": [
    {
      "name": "Value",
      "value": 5
    },
    {
      "name": "Rooms",
      "value": 5
    },
    {
      "name": "Location",
      "value": 5
    },
    {
      "name": "Cleanliness",
      "value": 5
    },
    {
      "name": "Service",
      "value": 5
    },
    {
      "name": "Sleep Quality",
      "value": 5
    }
  ],
  "photos": [],
  "placeInfo": {
    "id": "208453",
    "name": "Hilton New York Times Square",
    "webUrl": "https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html",
    "placeType": "ACCOMMODATION",
    "numberOfReviews": 9004
  },
  "scrapedAt": "2026-08-30T06:48:00.819365+00:00"
}
```

### ⚙️ How does it work?

TripAdvisor Review Scraper reads reviews straight from TripAdvisor's own paginated review API, 20 at a time, resolving place names and keywords to a TripAdvisor page first when you don't provide a direct URL. That API only accepts *persisted* queries — opaque 16-character ids that stand in for the query text and change whenever TripAdvisor edits the query — so before each place the Actor proves an id with a live one-review request. If none of the ids it already knows still works, it reads TripAdvisor's current front-end manifest from the CDN, finds the module that issues the review query, recovers the new id from it and caches that for later runs. Nothing is hardcoded that cannot repair itself.

One behaviour worth knowing: on an attraction page TripAdvisor's own review list also includes reviews of that attraction's bookable products (for example ticket and tour listings sold for the same landmark). Those rows are kept, because TripAdvisor genuinely publishes them on the page you asked for — and each one is attributed to the entity it actually reviews, so its `locationId`, `placeInfo` and review `url` all point at the product rather than at the parent landmark. Filter on `placeInfo.id` if you want the parent only. Only publicly visible review and hotel data is returned — nothing behind a login. Because the output schema is fixed by the Actor rather than by TripAdvisor's page markup, the field names and structure stay stable even when TripAdvisor changes its front-end.

### 🔗 Integrations

TripAdvisor Review Scraper runs like any other Apify Actor, so it works with the tools you already use to run Actors.

#### Calling TripAdvisor Review Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("tripadvisor-review-scraper-pay-per-events").call(run_input={
    "startUrls": ["https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html"],
    "maxComments": 200,
    "sortOrder": "newest",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request against the Apify API.

#### No-code tools (n8n, Make)

In n8n, use the official Apify node (or the HTTP Request node against the Apify API) to start a run and read back the dataset. In Make, the Apify app module can run the Actor and pass results into a subsequent scenario step, the same way it would for any other Apify Actor.

### ⚖️ Is it legal to scrape TripAdvisor reviews?

Scraping publicly available data — data any visitor can see without logging in — is generally lawful, and that is what TripAdvisor Review Scraper does. It returns only what's already visible on a place's public review page: no login, no bypassing an authentication wall.

Reviewer profile fields (name, username, location, avatar) returned when `scrapeReviewerInfo` is enabled are personal data, so GDPR (EU/UK) and CCPA (California) considerations apply to how you store, use, and retain that data — not to whether you may access the public page itself. Set `scrapeReviewerInfo` to `false` if you only need review text and ratings and want to avoid collecting personal data at all. Consult legal counsel if your use case involves bulk storage of personal data.

### ❓ Frequently asked questions

#### What TripAdvisor review fields does TripAdvisor Review Scraper return?

The top fields are `text`, `rating`, `subratings`, `title`, and `publishedDate`, plus the full reviewer profile in `user` and place metadata in `placeInfo`. See [What data can I extract](#-what-data-can-i-extract-with-tripadvisor-review-scraper) for every field.

#### Does TripAdvisor Review Scraper require a TripAdvisor account or login?

No. The Actor reads the same public review data any visitor sees; no TripAdvisor account, login, or API key is needed.

#### How many reviews can I extract in one run?

Up to 10,000 per place, set with `maxComments` (minimum 1, maximum 10,000). The Actor auto-paginates through TripAdvisor's 20-reviews-per-page API until it hits that number, the place's total review count, or its own 10,000-review safety cap.

#### What happens if a place name or keyword doesn't resolve?

`startUrls` accepts place names and keywords in addition to direct URLs. When you don't supply a direct review URL, the Actor resolves it via a Google search (TripAdvisor's own on-site search returns a bot challenge). If no matching place is found, that entry is skipped and logged with a warning — direct TripAdvisor URLs give the most reliable results.

#### Can I scrape multiple TripAdvisor places at once?

Yes — `startUrls` is an array. Add as many TripAdvisor URLs, place names, or keywords as you want and the Actor collects reviews for each one in the same run, applying the same settings to all of them.

#### Does TripAdvisor Review Scraper work with Claude, ChatGPT, and other AI agent tools?

It's callable as a standard HTTP endpoint through the Apify API by any agent framework that can make HTTP requests — see the Integrations section above for the `apify_client` example.

#### How does TripAdvisor Review Scraper compare to other TripAdvisor review scrapers?

Compare on documented capability rather than marketing copy: check what fields each scraper's own listing documents for the `user`, `subratings`, and `placeInfo` objects, and whether the listing states a review cap per place — this Actor documents a 10,000-review cap and a full reviewer profile object.

#### Does TripAdvisor Review Scraper return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with consistent field names across runs — no HTML, no selectors to write. Pass `text` and `subratings` straight into an LLM prompt, index them into a vector store, or feed them to an agent tool.

#### What happens when TripAdvisor changes its layout or anti-bot system?

The Actor's output schema is fixed by its own code, not by TripAdvisor's page markup, so field names stay stable even after a TripAdvisor front-end change. When TripAdvisor rotates its persisted-query ids the Actor detects it (the API answers a stale id with an empty `400`), rediscovers the current id from TripAdvisor's own CDN manifest, and carries on. If even that fails, the run logs a clear error and returns nothing for that place rather than silently returning wrong data.

#### Can I use TripAdvisor Review Scraper without managing proxies or browser infrastructure?

Yes. The Actor handles proxying (Residential by default), persisted-query resolution, and request retries itself — you don't configure any of that beyond the optional `proxyConfiguration` field. No browser is launched, so runs are fast and cheap.

#### Which fields work best for AI training data and RAG indexing?

For RAG, index `text` alongside `title`, `rating`, and `placeInfo.name` for grounding context. For structured training data, `rating`, `subratings`, `tripType`, and `travelDate` are the most consistently populated fields across records, all returned as typed primitives (strings, numbers, or nested objects) rather than free-form HTML.

### 🔗 Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| Google Maps Extractor | Places, business listings, and Google-side reviews for the same properties |
| Airbnb Rooms URLs Scraper | Airbnb host portfolios and co-host listing URLs |

### 💬 Your feedback

Found a bug, or need a field this Actor doesn't return yet? Leave a message in the Actor's Issues tab on the Apify Store, or reach out through Apify Console support — reports like these are how this scraper keeps working as TripAdvisor changes.

# Actor input Schema

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

📌 Drop one or more of the following — mix & match freely. Works for **hotels 🏨, restaurants 🍽️ and attractions 🎡** alike.

🌐 **Direct TripAdvisor URLs** — best results, fastest extraction
↳ `https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html`
↳ `https://www.tripadvisor.com/Restaurant_Review-g60763-d25218867-Reviews-Shmone-New_York_City_New_York.html`
↳ `https://www.tripadvisor.com/Attraction_Review-g60763-d105127-Reviews-Central_Park-New_York_City_New_York.html`

🏨 **Place names** — auto-resolved to a TripAdvisor page for you
↳ e.g. `Hilton New York Times Square`

🔍 **Keywords** — broader matches, may pick the most relevant place
↳ e.g. `luxury hotel New York`

💡 **Tip:** Direct URLs always give the most accurate results — name/keyword lookup can be hit-or-miss.

## `maxComments` (type: `integer`):

🎯 How many reviews to extract from each place.

⚡ Small runs (1–100) → seconds
🚀 Large runs (1000+) → minutes
💎 Enterprise (up to 10,000) → fully supported

📥 The scraper auto-paginates 20 reviews at a time — no need to click 'Next Page'.

## `sortOrder` (type: `string`):

🗂️ Choose the order in which reviews are fetched.

🆕 **newest** — most recent first (default, best for monitoring)
📜 **oldest** — earliest reviews first
⭐ **relevant** — TripAdvisor does not expose a distinct relevance ranking on this data source, so this currently returns the same order as "newest"
🏆 **rating** — highest rating first

## `reviewsLanguages` (type: `string`):

🗣️ Pick which language to extract reviews in.

🌐 Choose **All Languages** to keep every locale, or pick a specific language for a focused dataset.

## `reviewRatings` (type: `string`):

🎯 Choose which star ratings to keep after fetching.

🌟 **All Ratings** — keep every review (default)
👍 **Positive** — combine 4 + 5 star reviews
👎 **Negative** — combine 1 + 2 star reviews
😐 **Average** — only 3 star reviews

Or pick a specific star count for a single-tier dataset.

## `scrapeReviewerInfo` (type: `boolean`):

🪪 When enabled, each review row includes the full reviewer profile (name, username, location, avatar, contribution counts, profile link).

🔒 Disable for privacy-sensitive runs or when you only need review text + ratings — the `user` field becomes `null` in the output.

## `reviewQueryId` (type: `string`):

🔬 TripAdvisor's review API only accepts *persisted* queries, identified by a 16-character hex id that changes whenever TripAdvisor edits the query.

🤖 **You almost never need this.** The scraper tests the ids it already knows, and if TripAdvisor has rotated them it reads the current one straight out of TripAdvisor's own front-end and caches it for later runs.

✍️ Set this only if you want to pin a specific id, e.g. `ef3cb4f569f27e43`.

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

🔒 Routes requests through Apify Proxy. Every endpoint this scraper uses was verified to work on **direct, datacenter and residential** egress, so the proxy is about spreading request volume rather than getting past a block.

🏘️ **Residential** (default) — most headroom on TripAdvisor's rate limits
🏢 **Datacenter** — faster and cheaper, also verified working
🚫 **No proxy** — fine for small runs from a clean IP

## Actor input object example

```json
{
  "startUrls": [
    "https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html"
  ],
  "maxComments": 10,
  "sortOrder": "newest",
  "reviewsLanguages": "English",
  "reviewRatings": "ALL_REVIEW_RATINGS",
  "scrapeReviewerInfo": true,
  "reviewQueryId": "ef3cb4f569f27e43",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped reviews, one row per review, with rating, full text, reviewer info, owner response, photos and place info.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html"
    ],
    "reviewsLanguages": "English",
    "reviewRatings": "ALL_REVIEW_RATINGS",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/tripadvisor-review-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": ["https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html"],
    "reviewsLanguages": "English",
    "reviewRatings": "ALL_REVIEW_RATINGS",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/tripadvisor-review-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.tripadvisor.com/Hotel_Review-g60763-d208453-Reviews-Hilton_New_York_Times_Square-New_York_City_New_York.html"
  ],
  "reviewsLanguages": "English",
  "reviewRatings": "ALL_REVIEW_RATINGS",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraper-engine/tripadvisor-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/tripadvisor-review-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/KsazaBuVReNiDqm2E/builds/aPEiKaQVvkE2fIucE/openapi.json