# Tripadvisor Reviews Scraper: Ratings, Replies, Translations (`arcadium/tripadvisor-reviews`) Actor

Tripadvisor reviews for hotel, restaurant and attraction URLs or place names: rating, text, date, owner reply, sub-ratings; $4.50 per 1,000 reviews. No depth limit, optional translation, Tripadvisor-side filters. Only-new mode, free error rows, no reviewer names.

- **URL**: https://apify.com/arcadium/tripadvisor-reviews.md
- **Developed by:** [Arcadium Data](https://apify.com/arcadium) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Tripadvisor Reviews Scraper: Ratings, Replies, Translations

Give it Tripadvisor hotel, restaurant or attraction pages (or place names) and it returns one JSON row per review: rating, title, original-language text with an optional translation, date, sub-ratings, trip type, the owner reply with its date, and the place's overall rating and review count. $4.50 per 1,000 reviews on the free plan, less on paid plans; you pay only for rows you get.

**Why this actor**

- **No depth limit.** A place with 15,000 reviews is read to the end; stars, language, trip type, month and keyword filters are applied by Tripadvisor itself.
- **Only new reviews.** `onlyNewReviews` delivers just what earlier runs did not; repeats are not charged.
- **Real data or a clear error.** A free `coverage` row per place (stated vs delivered) and a free `error` row with a `code`, never a silent empty run.
- **Easy switch.** The input names of the most used Tripadvisor reviews actor are accepted as they are.

Built by Arcadium Data: public data, dated and agent-ready, never personal data.

### Use with AI agents

Returns Tripadvisor reviews (rating, text, date, owner reply, sub-ratings) for hotel, restaurant or attraction URLs or place names. Agents can call it through the Apify MCP server (`https://mcp.apify.com`, open source as `apify/actors-mcp-server`) as `arcadium/tripadvisor-reviews`: the input schema is read from the actor, the result is a dataset of JSON rows.

Input example (minimal):

```json
{
  "startUrls": [
    {
      "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html"
    }
  ],
  "maxReviewsPerPlace": 20
}
```

What comes back: one `review` row per review (charged) and, for an input that could not be read, one free `error` row. Filter on the `rowType` field. An input that fails is reported, not hidden (`includeErrorRows`, on by default): the error row carries `rowType: "error"`, a `code` (`invalid_input`, `not_found`, `blocked`, `unavailable`, `filter_unsupported` or `no_match`), a `message` and the `input` it is about. Retry on `blocked` and `unavailable` later; do not retry the other codes with the same input.

Cost of the call above: 20 reviews at $4.50 per 1,000 plus the $0.001 start fee is about $0.09 on the free plan; paid plans pay less. Free rows are never charged.

### What you get

| Field | What it holds |
| --- | --- |
| `reviewId` | `Tripadvisor___` plus the platform's own review ID. Stable between runs, so you can dedupe weekly exports. |
| `date` | Date the review was written, ISO format. |
| `title`, `text` | What the reviewer wrote, in the language it was written in. |
| `extras.translatedTitle`, `extras.translatedText`, `extras.translatedLanguage` | Machine translation of a review written in another language, next to the original. Only with `translateTo`. |
| `extras.originalLanguage` | Language the review was written in. |
| `product.rating`, `product.reviewCount` | `rating` is the average of all review ratings of the place (computed from its star histogram, not Tripadvisor's rounded bubble rating); `reviewCount` is the total number of reviews. Repeated on every row. Turn off with `includePlaceSummary`. |
| `ratingOverall` | Overall bubble rating, 1 to 5. |
| `ratings` | Sub-ratings the reviewer filled in (value, rooms, location, cleanliness, service, sleep quality). Skipped ones are left out. |
| `vendorResponse`, `extras.ownerResponseDate` | The owner or manager reply and the date it was posted, when there is one. |
| `helpfulVotes`, `language`, `reviewerVerified` | Helpful votes, review language, and whether the review is marked as verified. |
| `productName`, `productUrl`, `reviewUrl` | The place and where the review lives. |
| `extras.tripType` | Business, couples, family, friends or solo. |
| `extras.visitDate` | Month of the visit (yyyy-mm). |
| `extras.photoUrls` | Photos attached to the review. |
| `extras.totalCount` | How many reviews match your filters at that place. |
| `scrapedAt` | When the row was collected. |

Output example:

```json
{
  "reviewId": "Tripadvisor___123456789",
  "platform": "tripadvisor",
  "productName": "Example Grand Hotel",
  "date": "2026-09-27",
  "title": "Great stay",
  "text": "Quiet room, friendly staff.",
  "ratingOverall": 5,
  "ratings": { "value": 5, "cleanliness": 5 },
  "language": "en",
  "vendorResponse": "Dear [name], thank you for staying with us.",
  "extras": { "tripType": "COUPLES", "visitDate": "2026-08", "placeType": "ACCOMMODATION" }
}
```

### Input

```json
{
  "startUrls": [{ "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html" }],
  "maxReviewsPerPlace": 100
}
```

| Field | What it does |
| --- | --- |
| `startUrls` | Hotel, restaurant or attraction pages on any Tripadvisor domain. |
| `searchQueries` | Place names. The best match for each name is scraped. Use URLs when you need an exact place. |
| `maxReviewsPerPlace` | Cap per place (default 100, up to 50,000). |
| `sort` | `MOST_RECENT` (default), `DETAILED` or `INSIGHTFUL`. |
| `ratings` | Only these star ratings, for example `["1", "2"]`. |
| `languages` | Only these review languages, for example `["de"]`. Several languages are read as separate passes and merged newest first. |
| `tripTypes`, `visitMonths` | Only these traveler types or months of the visit. |
| `keyword` | Only reviews that mention it. Tripadvisor caps keyword results at 1,000. |
| `translateTo` | Language code such as `en`. Reviews in other languages also get a machine translation (Tripadvisor translates reviews from roughly the last two years only). |
| `includePlaceSummary` | Adds the place rating and review count to every row (default on, five small extra requests per place). |
| `dateFrom` | Only reviews from this date on. Stops early with the newest first sort. |
| `onlyNewReviews`, `stateKey` | Skip reviews that earlier runs with the same key already delivered. They are not charged. |
| `includeErrorRows` | One free row per place that could not be read, with the reason. |

### Coverage and edited reviews

A free `coverage` row per place says how many reviews the source reports against how many you received, and why reading stopped (your cap, the source's cap, or the end). With `onlyNewReviews`, a review that was edited after it was delivered comes back once more with `extras.changeType` set to `edited`; that row is charged like a new review.

### Migrating from maxcopell

The input of the other popular Tripadvisor reviews actor works as it is. These field names are accepted and mapped:

| Their field | Used as |
| --- | --- |
| `startUrls` | `startUrls` |
| `maxItemsPerQuery` | `maxReviewsPerPlace` |
| `lastReviewDate` (a date, a full ISO datetime, or `3 days`, `3 Days ago`, `-2 weeks`, `12 hours`) | `dateFrom` |
| `reviewRatings` (`ALL_REVIEW_RATINGS` or `1` to `5`) | `ratings` |
| `reviewsLanguages` (`ALL_REVIEW_LANGUAGES` or a code) | `languages` |
| `disableMachineTranslations` | `false` adds an English translation next to the original, `true` returns originals only |
| `scrapeReviewerInfo`, `sourceDatasetId` | Ignored. Reviewer names and profiles are never returned. |

Example, pasted unchanged:

```json
{
  "startUrls": [{ "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html" }],
  "maxItemsPerQuery": 200,
  "lastReviewDate": "2026-09-01",
  "reviewRatings": ["ALL_REVIEW_RATINGS"],
  "reviewsLanguages": ["ALL_REVIEW_LANGUAGES"],
  "disableMachineTranslations": false
}
```

Output field names are our own (see the table above), so check any downstream mapping once.

### Use it from an AI assistant

Paste this into your assistant to run the actor for you:

```text
Use the Apify actor "tripadvisor-reviews" to collect reviews.
Input: {"startUrls":[{"url":"<Tripadvisor hotel, restaurant or attraction URL>"}],"maxReviewsPerPlace":100}
Each dataset row is one review. Key fields: reviewId, date, title, text, ratingOverall, extras.tripType.
Run it, then summarize the main praise and complaints. Mention the review count.
```

### Use it from code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("arcadium/tripadvisor-reviews").call(run_input={
    "startUrls": [{"url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html"}],
    "maxReviewsPerPlace": 100,
    "ratings": ["1", "2"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["date"], item["ratingOverall"], item["title"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('arcadium/tripadvisor-reviews').call({
  searchQueries: ['hyatt grand central new york'],
  maxReviewsPerPlace: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'reviews');
```

### Pricing

You pay per review returned. Failed or empty lookups are not charged.

You pay per review delivered, at the price of your Apify plan. Error rows, coverage rows and repeats in only-new mode are free.

| Apify plan | Per 1,000 reviews |
| --- | --- |
| Free | $4.50 |
| Starter (Bronze) | $1.75 |
| Scale (Silver) | $1.35 |
| Business (Gold) | $0.80 |
| Platinum | $0.45 |
| Diamond | $0.27 |

Plus a one-off $0.001 per GB of memory when a run starts.

Set a maximum cost per run in the Apify run options and the actor stops before it goes over.

### Related actors and data

- [Hotel Reviews Scraper: Tripadvisor, Booking.com, Google](https://apify.com/arcadium/hotel-reputation)
- [Booking.com Reviews Scraper: Pros, Cons, Reviewer Country](https://apify.com/arcadium/booking-reviews)
- [Google Hotel Reviews Scraper: Topics, Replies, Partner Sites](https://apify.com/arcadium/google-hotel-reviews)
- [Review Monitor: Negative Review Alerts and Rating Drift](https://apify.com/arcadium/reputation-monitor)
- [Hotel demand peaks report](https://arcadiumdata.io/reports/hotel-demand-peaks/): the next 90 nights of hotel rates by city, with spike nights flagged.
- [Arcadium Data MCP Server](https://apify.com/arcadium/arcadium-mcp): AI agents can ask the same questions as tools (`search_reviews`, `hotel_prices`, `city_rate_curve`, `review_snapshot`).

### Use cases

- Competitor tracking: export a rival hotel's newest reviews every week and watch what changes.
- Reputation monitoring: pull only the 1 and 2 star reviews of your own places, in every language.
- Sentiment analysis: feed review text, trip type and sub-ratings into your own model or spreadsheet.
- Market research: compare restaurants or attractions in one city side by side.

### Limitations

- Public reviews only. Nothing behind a login.
- `title` and `text` are always the original. A translation exists only when you set `translateTo`, and it is Tripadvisor's own machine translation. Tripadvisor does not translate reviews older than about two years, so those rows have no `extras.translatedText`. If translation stops working during a run, the remaining rows are delivered without it.
- A keyword search returns at most 1,000 reviews, a limit set by Tripadvisor.
- Several languages in one run are read as separate passes and merged newest first, so `dateFrom` and `onlyNewReviews` keep their early stop. With another sort the passes are delivered one after another.
- Name search picks the best match only. For hotels with common names, use the URL.
- Sub-ratings exist only where the reviewer filled them in, and the set differs between hotels, restaurants and attractions.
- Tripadvisor changes its site from time to time. The actor adapts on its own in most cases; if a run fails for several places at once, try again later or open an issue.

### Privacy

Reviewer names, profile photos, profile links, hometowns, emails and phone numbers are never collected. Names in greetings and sign-offs (for example 'Dear John' or 'Regards, Anna') are replaced with \[name]; other names in the text are not detected. The reviewer's own display name and handle are also masked wherever they appear in the text. You get the review and the context around it, not the person.

### FAQ

**How fresh is the data?**
It is read when you run the actor, so it matches what the site shows at that moment.

**Can I get only new reviews since my last run?**
Yes. Turn on `onlyNewReviews` and keep the same `stateKey` between runs. Reviews you already received are skipped and not charged. The state lives in a key-value store in your Apify account. Pick a new `stateKey` to start over.

**Does the actor store anything in my account?**
Yes, one small named key-value store, `tripadvisor-reviews-state`. It caches the identifiers of Tripadvisor's own review queries so the next run starts faster, and it holds the `onlyNewReviews` state. It contains no review text.

**A place returned no reviews. Why?**
Check that the URL opens a hotel, restaurant or attraction page in your browser. Places without reviews return a free error row.

**Something looks wrong in the output. Who do I tell?**
Open an issue on the actor page with the run link. We read them all.

# Actor input Schema

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

Hotel, restaurant or attraction pages, e.g. https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html. Any Tripadvisor domain works. Add this, search queries, or both.

## `searchQueries` (type: `array`):

Place names to look up, for example 'hyatt grand central new york'. The best match for each name is scraped. Use URLs when you need an exact place.

## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews to collect for each place (up to 50,000).

## `sort` (type: `string`):

Order of the reviews. Most recent is newest first and enables the date filter and the incremental mode.

## `ratings` (type: `array`):

Only reviews with these star ratings (1 to 5). Leave empty for all.

## `languages` (type: `array`):

Only reviews written in these languages, as two-letter codes such as en, de, fr. Leave empty for all languages. Each language is read in its own pass.

## `tripTypes` (type: `array`):

Only reviews from these kinds of travelers. Leave empty for all.

## `visitMonths` (type: `array`):

Only reviews about visits in these months (any year). Leave empty for all.

## `keyword` (type: `string`):

Only reviews that mention this word or phrase. Tripadvisor returns at most 1,000 matches for a keyword search. Example: breakfast.

## `translateTo` (type: `string`):

Language code (for example en). Reviews written in other languages get a machine translation in extras.translatedText next to the original text. Tripadvisor only translates reviews from roughly the last two years. Leave empty for originals only.

## `includePlaceSummary` (type: `boolean`):

Adds the place's overall rating and total review count to every row (product.rating, product.reviewCount). Costs five small extra requests per place; turn off if you only need the review text.

## `dateFrom` (type: `string`):

Only keep reviews written on or after this date (YYYY-MM-DD, or a relative span such as 30 days or 2 months; empty = no filter). With the most recent sort, reading stops once reviews are older.

## `onlyNewReviews` (type: `boolean`):

Skip reviews delivered by earlier runs that used the same state key, and do not charge for them. Forces the most recent sort.

## `stateKey` (type: `string`):

Name of the incremental state (letters, digits and dashes). Change it to start over. State is kept in a key-value store in your account. Example: weekly-monitoring.

## `includeErrorRows` (type: `boolean`):

Add one row per place that could not be read, with the reason. These rows are free.

## `maxRetries` (type: `integer`):

How many times a failed request is retried.

## `queryIdOverride` (type: `string`):

Advanced: a 16 character hex id of the reviews query to try first. Leave empty; the actor finds a working id by itself.

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

Advanced: use your own proxy. By default the actor picks the cheapest tier that works.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html"
    }
  ],
  "maxReviewsPerPlace": 20,
  "sort": "MOST_RECENT",
  "includePlaceSummary": true,
  "onlyNewReviews": false,
  "stateKey": "default",
  "includeErrorRows": true,
  "maxRetries": 3
}
```

# Actor output Schema

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

All rows of this run in the default dataset.

## `view_overview` (type: `string`):

No description

## `view_ratings` (type: `string`):

No description

## `view_errors` (type: `string`):

No description

## `view_translations` (type: `string`):

No description

## `view_owner` (type: `string`):

No description

## `record_stats` (type: `string`):

Requests, data volume, retries and cost per result for this run.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html"
        }
    ],
    "maxReviewsPerPlace": 20
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html" }],
    "maxReviewsPerPlace": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93450-Reviews-Hyatt_Grand_Central_New_York-New_York_City_New_York.html"
    }
  ],
  "maxReviewsPerPlace": 20
}' |
apify call arcadium/tripadvisor-reviews --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arcadium/tripadvisor-reviews"
        }
    }
}
```

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/VfKGk2mOOfsMn60an/builds/X42gcvaduJaXok2Du/openapi.json