# Tripadvisor Reviews Scraper (`axlymxp/tripadvisor-reviews-scraper`) Actor

Scrape Tripadvisor reviews for attractions, hotels and restaurants by URL, ID or name. Get rating, title, full text, dates, trip type, author, hotel and restaurant sub-ratings, photos and owner responses. Filter by language, stars, date and trip type.

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

## Pricing

from $2.00 / 1,000 dataset items

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/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

Collect Tripadvisor reviews for **attractions, hotels and restaurants** as clean, flat rows: rating, title, full text, review date, trip type, author, sub-ratings (rooms, service, food, ...), photos and the owner's reply. Point it at place URLs or IDs, or just type place names. It is built for reputation monitoring, competitor benchmarking, sentiment and NLP datasets, and travel research.

The actor reads Tripadvisor's mobile-app data feed, so it needs no login and no browser. Every place is read page by page (20 reviews per page) until your limit or the last review.

### Output fields

| Field | Description |
| --- | --- |
| `review_id`, `review_url` | Tripadvisor review ID and its canonical link |
| `place_id`, `place_type`, `place_name`, `place_url` | The attraction, hotel or restaurant the review belongs to |
| `rating` | 1 to 5 |
| `title`, `text` | Review headline and full text (plain text, line breaks kept) |
| `published_text`, `published_date`, `published_date_is_approximate` | Date as Tripadvisor shows it ("3 days ago", "Dec 3, 2022") and an ISO date. Recent reviews only carry relative text, so their ISO date is approximate (true) |
| `visit_date_text`, `visit_month` | When the reviewer travelled ("Sept 2026" and `2026-09`) |
| `trip_type` | Business, Couples, Family, Friends or Solo |
| `author_name`, `author_location`, `author_contributions`, `author_profile_url` | Reviewer details as shown on the review |
| `helpful_votes` | Number of "Helpful" votes |
| `sub_ratings` | Hotels and restaurants: for example `{"Rooms": 5, "Service": 4}` |
| `owner_response` | Management reply: `text`, `author`, `author_position`, `published_text`, `published_date`, `profile_url` |
| `tip`, `label` | Reviewer tip and badges such as "HOTEL'S FAVORITE", when present |
| `is_translated` | `true` when the text was machine-translated to English by Tripadvisor |
| `photo_count`, `photos` | Reviewer photo links |
| `scraped_at` | UTC timestamp |

### Use cases

- **Reputation monitoring**: schedule a daily run with `reviewsSince` set to yesterday and send new reviews and owner replies to Slack, a sheet or a webhook.
- **Competitor benchmarking**: compare ratings, complaints and response rates across hotels or restaurants in one city.
- **Sentiment and NLP datasets**: large review corpora with star labels, trip type and language filters.
- **Hospitality and tourism research**: seasonality (`publishedMonths`), trip-type mix and sub-rating trends.

### Input

| Field | Description |
| --- | --- |
| `placeUrls` | Tripadvisor `Attraction_Review`, `Hotel_Review` or `Restaurant_Review` URLs from any Tripadvisor domain, or IDs such as `hotel:188730`, `restaurant:719141`, `attraction:188151` |
| `searchQueries` | Place names to look up, e.g. `Hotel Plaza Athenee Paris`. `placeTypes` and `maxPlacesPerQuery` control what is scraped |
| `maxReviewsPerPlace` | Reviews to collect per place. `0` = all matching reviews |
| `language` | `all` (default) or one language. With `all` or `en`, non-English reviews arrive translated to English (`is_translated`); a specific language returns the original text |
| `ratings`, `tripTypes`, `reviewsSince`, `publishedMonths` | Tripadvisor's own review filters (stars, trip type, written on or after a date, written in these calendar months) |
| `concurrency` | Places scraped in parallel (reviews inside one place are read in order) |
| `proxyConfiguration` | Datacenter proxy by default. After repeated blocks the run switches to Apify RESIDENTIAL automatically |

```json
{
    "placeUrls": [
        "https://www.tripadvisor.com/Hotel_Review-g187147-d188730-Reviews-Hotel_Plaza_Athenee-Paris_Ile_de_France.html"
    ],
    "searchQueries": ["Le Jules Verne Paris"],
    "placeTypes": ["restaurant"],
    "maxReviewsPerPlace": 200,
    "language": "all",
    "ratings": ["1", "2"],
    "reviewsSince": "2026-01-01"
}
```

### Scheduling and webhooks

Run it on a schedule with `reviewsSince` set to your last run date, then use an Apify webhook or integration to push the new rows to your tools. Rows are pushed as they are collected, and an interrupted run resumes from where it stopped.

### Using it from AI agents and pipelines

The dataset is flat JSON/CSV, so it works with the Apify API, the Python and JavaScript clients, and any MCP-compatible agent that can call Apify Actors.

### FAQ

**Do I need a Tripadvisor account?** No.

**Why is the date sometimes approximate?** Tripadvisor's app shows "3 days ago" for recent reviews and a full date for older ones. The ISO date for relative text is calculated from the scrape time, so it can be a day off (for weeks and months it is rougher). `published_date_is_approximate` tells you which.

**Can I get every review of a very popular place?** Yes, set `maxReviewsPerPlace` to `0`. Reviews are read in order at roughly 10 reviews per second per place, so a place with 100,000+ reviews takes hours. Split it with the star-rating or date filters and run the slices in parallel as separate runs.

**Are all languages covered?** Yes. Choose `all` or a specific language.

**What happens when Tripadvisor blocks an IP?** The request is retried on a fresh IP, and after repeated blocks the run switches to RESIDENTIAL proxies.

# Actor input Schema

## `placeUrls` (type: `array`):

Tripadvisor attraction, hotel or restaurant pages (…/Attraction_Review-…, …/Hotel_Review-…, …/Restaurant_Review-… on any Tripadvisor domain), or short IDs such as hotel:188730 / restaurant:719141 / attraction:188151.

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

Find places by name instead of URL, e.g. "Hotel Plaza Athenee Paris". The best matches are scraped (see Max places per search term).

## `placeTypes` (type: `array`):

Which kinds of places a search term may resolve to.

## `maxPlacesPerQuery` (type: `integer`):

How many of the best-matching places to scrape for each search term.

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

Stop after this many reviews for each place. 0 = every review that matches the filters. You are charged per review.

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

Language of the reviews to collect. Tripadvisor's own default is English only, so "All languages" is the default here. With "All languages" or English, reviews written in other languages come back machine-translated to English by Tripadvisor (is_translated = true); pick a specific language to get the original text.

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

Only collect reviews with these ratings. Empty = all ratings.

## `reviewsSince` (type: `string`):

Only reviews written on or after this date, format YYYY-MM-DD. Handy for monitoring: schedule the actor and set this to the last run date.

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

Only reviews from these kinds of trips. Empty = all.

## `publishedMonths` (type: `array`):

Only reviews that were written (published) in these calendar months, any year. Useful for seasonality studies. Empty = all months.

## `concurrency` (type: `integer`):

How many places are scraped at the same time. Reviews inside one place are fetched page by page.

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

Datacenter proxy by default. If Tripadvisor blocks several exits in a row the run switches to Apify RESIDENTIAL automatically (charged as proxy traffic on your plan).

## Actor input object example

```json
{
  "placeUrls": [
    "https://www.tripadvisor.com/Attraction_Review-g187147-d188151-Reviews-Eiffel_Tower-Paris_Ile_de_France.html"
  ],
  "placeTypes": [
    "attraction",
    "hotel",
    "restaurant"
  ],
  "maxPlacesPerQuery": 1,
  "maxReviewsPerPlace": 100,
  "language": "all",
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "placeUrls": [
        "https://www.tripadvisor.com/Attraction_Review-g187147-d188151-Reviews-Eiffel_Tower-Paris_Ile_de_France.html"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "placeUrls": ["https://www.tripadvisor.com/Attraction_Review-g187147-d188151-Reviews-Eiffel_Tower-Paris_Ile_de_France.html"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/tripadvisor-reviews-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 '{
  "placeUrls": [
    "https://www.tripadvisor.com/Attraction_Review-g187147-d188151-Reviews-Eiffel_Tower-Paris_Ile_de_France.html"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axlymxp/tripadvisor-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axlymxp/tripadvisor-reviews-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/gkJdmfteJZMbD3lSW/builds/0ockMIC6bLvceBmXd/openapi.json