# TripAdvisor Reviews Scraper - Bulk Hotels, Restaurants (`jdtpnjtp/tripadvisor-reviews-bulk`) Actor

Bulk-pull every review from any TripAdvisor hotel, restaurant or attraction. Hand a list of TripAdvisor location IDs or URLs (up to 200 per run) and get every individual review as its own dataset row - no subscription, $0.0008 per review.

- **URL**: https://apify.com/jdtpnjtp/tripadvisor-reviews-bulk.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Travel, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 tripadvisor review row extracteds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## TripAdvisor Reviews Scraper - Bulk Hotels, Restaurants

**Pull every review from a list of TripAdvisor hotels, restaurants or attractions in one run.** Hand the actor a batch of TripAdvisor location IDs or URLs, and get every individual review as its own clean dataset row - ready for CSV, Excel, sentiment analysis or a dashboard. No subscription, you only pay per review.

---

### What this actor does

- **Bulk by design** - up to **200 locations** per run, up to **5000 reviews** each.
- **IDs or URLs, mixed** - paste numeric `location_id`s or full `Hotel_Review` / `Restaurant_Review` / `Attraction_Review` URLs; IDs are auto-extracted.
- **Real filters** - language (or all languages), star rating, traveler type (families / couples / solo / business / friends), free-text keyword search, and sort order.
- **One flat row per review** - rating, title, full text, reviewer, dates, trip type, helpful votes, photos. No nested objects to flatten.
- **You only pay for reviews** - locations that fail get a single free diagnostic row; the run keeps going.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| **locations** | array | **Yes** | Up to 200 TripAdvisor `location_id`s or review-page URLs (mixed). |
| maxReviewsPerLocation | integer | No | Cap per location (prefill 50; up to 10000). |
| language | string | No | Review language, or `all` for every language (default `en`). |
| sort | string | No | most_relevant / newest / oldest / highest / lowest. |
| ratingFilter | array | No | Keep only chosen star ratings (1-5). Empty = all. |
| travelerType | string | No | families / couples / solo / business / friends. |
| textSearch | string | No | Keep only reviews containing this text. |
| stopOnLocationError | boolean | No | Abort the whole run on the first failing location (default off). |

Example: `{ "locations": ["1218720", "https://www.tripadvisor.com/Restaurant_Review-g187147-d12947099-Reviews-Septime-Paris.html"], "maxReviewsPerLocation": 100, "language": "en", "sort": "most_relevant" }`

### Output

One row per review. Columns: `location_id`, `location_input`, `review_id`, `rating`, `title`, `text`, `language`, `published_date`, `stay_date`, `trip_type`, `reviewer_name`, `reviewer_location`, `helpful_votes`, `photos`. Diagnostic rows (a whole location failed) carry `error_code` + `error_message` instead. A run-summary `OUTPUT` record reports locations succeeded/failed, reviews pulled and the estimated cost. Live per-review pricing is shown on this actor's Apify Store page.

### Why this actor

- **Reviews specialist** - built for one job and does it at scale: thousands of reviews across hundreds of places in a single run.
- **Export-ready** - flat columns render as a real table you can sort, filter and download as CSV/Excel/JSON in one click.
- **Honest billing** - failed locations are free; you pay only for review rows actually delivered.
- **Mix IDs and URLs** - no pre-processing; throw in whatever you have.

### More TripAdvisor tools

Part of the USP Ultimate TripAdvisor suite - pick the actor that fits the job:

- **[TripAdvisor Hotels, Restaurants & Cruises Scraper](https://apify.com/jdtpnjtp/tripadvisor)** - search a whole destination across 5 verticals (hotels, restaurants, things to do, vacation rentals, cruises).
- **[TripAdvisor URL Parser](https://apify.com/jdtpnjtp/tripadvisor-url-parser)** - paste any TripAdvisor URLs and get the parsed payload per URL.

Prefer the raw API across all 21 TripAdvisor endpoints with your own key? See the USP Ultimate TripAdvisor API on RapidAPI.

### Need help? Enterprise plans? Custom scraping?

I personally support every customer - drop a message on any channel.

[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge&logo=whatsapp&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge&logo=gmail&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

## `locations` (type: `array`):

Up to 200 entries. Each entry is either a numeric TripAdvisor location_id (e.g. `1218720`) or a full TripAdvisor URL containing a `-d{ID}-` segment (Hotel_Review / Restaurant_Review / Attraction_Review). URLs and IDs can be mixed in one run.
## `maxReviewsPerLocation` (type: `integer`):

Hard cap per location_id. The actor stops paginating each place once it has pushed this many review rows. Common values: 100 = sample, 500 = decent dataset, 5000 = deep crawl.
## `language` (type: `string`):

Language of reviews to keep. Pick **All languages** to keep every review, or a specific language to keep only reviews TripAdvisor tagged with it (others are skipped). You can also type any TripAdvisor language code (e.g. `cs`, `th`).
## `sort` (type: `string`):

Order in which TripAdvisor returns reviews. `most_relevant` matches the default web view; `newest` / `oldest` go strictly by date; `highest` / `lowest` go by rating.
## `ratingFilter` (type: `array`):

Keep only reviews with these star ratings. Leave empty to keep all. Tip: pick 1★ and 2★ to mine complaints, or 5★ for testimonials.
## `travelerType` (type: `string`):

Restrict to reviews written by a specific traveler type. Leave blank for all.
## `textSearch` (type: `string`):

Optional substring filter applied server-side. Reviews not containing this text are skipped. Use for keyword mining (e.g. "WiFi", "breakfast", "noise").
## `stopOnLocationError` (type: `boolean`):

If true, the run aborts as soon as any one location_id fails (NOT_FOUND / UPSTREAM_BLOCKED / INVALID_INPUT). If false (default), failing locations are skipped with one diagnostic row and the run continues to the next location.

## Actor input object example

```json
{
  "locations": [
    "1218720",
    "https://www.tripadvisor.com/Restaurant_Review-g187147-d12947099-Reviews-Septime-Paris_Ile_de_France.html"
  ],
  "maxReviewsPerLocation": 50,
  "language": "en",
  "sort": "most_relevant",
  "ratingFilter": [],
  "travelerType": "",
  "textSearch": "",
  "stopOnLocationError": false
}
````

# Actor output Schema

## `dataset` (type: `string`):

The default dataset. Each row carries one TripAdvisor review (review\_id, rating, title, text, language, published\_date, stay\_date, trip\_type, reviewer\_name, reviewer\_location, helpful\_votes, photos), linked to its source location via location\_id. Diagnostic rows carry an error\_code instead of review fields.

## `summary` (type: `string`):

A single JSON object written to the default key-value store under the OUTPUT key. Contains locations\_received, locations\_succeeded, locations\_failed, reviews\_charged, estimated\_cost\_usd, limit\_reached, and actor\_version.

# 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 = {
    "locations": [
        "1218720",
        "https://www.tripadvisor.com/Restaurant_Review-g187147-d12947099-Reviews-Septime-Paris_Ile_de_France.html"
    ],
    "maxReviewsPerLocation": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/tripadvisor-reviews-bulk").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 = {
    "locations": [
        "1218720",
        "https://www.tripadvisor.com/Restaurant_Review-g187147-d12947099-Reviews-Septime-Paris_Ile_de_France.html",
    ],
    "maxReviewsPerLocation": 50,
}

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

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

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

```

## CLI example

```bash
echo '{
  "locations": [
    "1218720",
    "https://www.tripadvisor.com/Restaurant_Review-g187147-d12947099-Reviews-Septime-Paris_Ile_de_France.html"
  ],
  "maxReviewsPerLocation": 50
}' |
apify call jdtpnjtp/tripadvisor-reviews-bulk --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TripAdvisor Reviews Scraper - Bulk Hotels, Restaurants",
        "description": "Bulk-pull every review from any TripAdvisor hotel, restaurant or attraction. Hand a list of TripAdvisor location IDs or URLs (up to 200 per run) and get every individual review as its own dataset row - no subscription, $0.0008 per review.",
        "version": "1.0",
        "x-build-id": "Sg5CnSzMjPEKKfVm5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~tripadvisor-reviews-bulk/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-tripadvisor-reviews-bulk",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/jdtpnjtp~tripadvisor-reviews-bulk/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-tripadvisor-reviews-bulk",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/jdtpnjtp~tripadvisor-reviews-bulk/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-tripadvisor-reviews-bulk",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "TripAdvisor locations",
                        "minItems": 1,
                        "maxItems": 200,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Up to 200 entries. Each entry is either a numeric TripAdvisor location_id (e.g. `1218720`) or a full TripAdvisor URL containing a `-d{ID}-` segment (Hotel_Review / Restaurant_Review / Attraction_Review). URLs and IDs can be mixed in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerLocation": {
                        "title": "Max reviews per location",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap per location_id. The actor stops paginating each place once it has pushed this many review rows. Common values: 100 = sample, 500 = decent dataset, 5000 = deep crawl.",
                        "default": 500
                    },
                    "language": {
                        "title": "Review language",
                        "type": "string",
                        "description": "Language of reviews to keep. Pick **All languages** to keep every review, or a specific language to keep only reviews TripAdvisor tagged with it (others are skipped). You can also type any TripAdvisor language code (e.g. `cs`, `th`).",
                        "default": "en"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "most_relevant",
                            "newest",
                            "oldest",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "Order in which TripAdvisor returns reviews. `most_relevant` matches the default web view; `newest` / `oldest` go strictly by date; `highest` / `lowest` go by rating.",
                        "default": "most_relevant"
                    },
                    "ratingFilter": {
                        "title": "Star ratings to include",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only reviews with these star ratings. Leave empty to keep all. Tip: pick 1★ and 2★ to mine complaints, or 5★ for testimonials.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "★ 1 - Terrible",
                                "★★ 2 - Poor",
                                "★★★ 3 - Average",
                                "★★★★ 4 - Very good",
                                "★★★★★ 5 - Excellent"
                            ]
                        },
                        "default": []
                    },
                    "travelerType": {
                        "title": "Traveler type",
                        "enum": [
                            "",
                            "families",
                            "couples",
                            "solo",
                            "business",
                            "friends"
                        ],
                        "type": "string",
                        "description": "Restrict to reviews written by a specific traveler type. Leave blank for all.",
                        "default": ""
                    },
                    "textSearch": {
                        "title": "Text search (within review body)",
                        "type": "string",
                        "description": "Optional substring filter applied server-side. Reviews not containing this text are skipped. Use for keyword mining (e.g. \"WiFi\", \"breakfast\", \"noise\").",
                        "default": ""
                    },
                    "stopOnLocationError": {
                        "title": "Stop the whole run on the first location error",
                        "type": "boolean",
                        "description": "If true, the run aborts as soon as any one location_id fails (NOT_FOUND / UPSTREAM_BLOCKED / INVALID_INPUT). If false (default), failing locations are skipped with one diagnostic row and the run continues to the next location.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
