# TripAdvisor Hotel, Restaurant & Attraction Finder (`nimbryxo-studio/tripadvisor-hotel-restaurant-and-attraction-finder`) Actor

Search TripAdvisor by phrase or place URL for hotels, restaurants, and attractions, with rating, ranking, address, contact details, and pricing per place.

- **URL**: https://apify.com/nimbryxo-studio/tripadvisor-hotel-restaurant-and-attraction-finder.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Automation, Lead generation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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.
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 Hotel, Restaurant & Attraction Finder

Look up hotels, restaurants, and attractions on TripAdvisor by search phrase or by pasting the place's own TripAdvisor URL. Each result comes back as a structured record with rating, ranking, address, contact details, pricing, and category-specific fields like hotel class or cuisine type.

### What this actor does

- Turns a search phrase such as `hotels in Paris` into a destination (here, Paris) and collects the places TripAdvisor lists for it
- Scrapes specific places directly from their TripAdvisor URL instead of searching
- Mixes search queries and direct URLs in the same run, returning each place only once
- Uses `placeType` to pick hotels, restaurants, attractions, or a mixed destination overview for searches
- Pulls category-specific detail when the source has it: hotel star class for hotels, cuisine types for restaurants
- Fields TripAdvisor has no value for come back as an empty string rather than being dropped, so every record keeps the same set of columns

### Output per place

All values are text, including numbers and flags (for example `"4.5"` or `"False"`).

- `locationId` — TripAdvisor's internal ID for the place
- `name`, `type`, `subcategory` — place name, TripAdvisor's type key for it (e.g. `hotel`, `restaurant`, `attraction`), and sub-category label
- `address`, `street`, `city`, `state`, `country`, `postalCode` — address, both as one string and broken out by component
- `latitude`, `longitude` — geographic coordinates
- `rating`, `numberOfReviews` — overall rating (0–5) and total review count
- `rankingPosition`, `rankingString` — numeric rank and the full ranking text, e.g. `#20 of 583 hotels in New York City`
- `priceLevel`, `priceRange` — price symbols (e.g. `$$$$`) and the price range text
- `phone`, `email`, `website` — contact details, when published
- `hotelClass` — star rating, hotels only
- `cuisine` — cuisine types, restaurants only
- `hours` — operating hours, when published
- `description` — the place's description text
- `neighborhoods` — neighborhood name(s) the place is located in
- `webUrl` — the TripAdvisor page URL for the place
- `isClosed` — `"True"` or `"False"`, whether TripAdvisor marks the place as closed
- `photoUrl` — main photo URL, when available
- `searchQuery` — the search phrase that returned this place (empty string for places from `startUrls`)
- `scrapeTimestamp` — when the run started (the same value on every record of a run)

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array of strings | – | Search phrases naming a destination, e.g. `hotels in Paris`. Words such as "hotels", "best" or "in" are stripped to find the destination; the kind of place returned is set by `placeType`. |
| `startUrls` | array of strings | – | Direct TripAdvisor place URLs (hotel, restaurant, or attraction review pages). |
| `maxItems` | integer | `50` | Maximum places to return per search query (1–100). |
| `placeType` | string | `all` | Which TripAdvisor list to read for each search destination: `hotel`, `restaurant`, `attraction`, or `all` (the destination's overview page, which mixes hotels, restaurants, attractions and sometimes vacation rentals). Has no effect on `startUrls`. |
| `proxyConfiguration` | object | – | Proxy settings for search queries; if left unset, the actor provisions a residential proxy automatically. Direct URLs don't need one. |

At least one of `searchQueries` or `startUrls` must be provided.

### Example: scrape specific places by URL

```json
{
  "startUrls": [
    "https://www.tripadvisor.com/Hotel_Review-g60763-d675616-Reviews-The_Plaza_New_York-New_York_City_New_York.html",
    "https://www.tripadvisor.com/Restaurant_Review-g60763-d457808-Reviews-Daniel-New_York_City_New_York.html"
  ]
}
```

### Example: search for hotels in a city

```json
{
  "searchQueries": ["hotels in Paris"],
  "maxItems": 10,
  "placeType": "hotel",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example: combine a search with a specific attraction URL

```json
{
  "searchQueries": ["best restaurants London"],
  "startUrls": ["https://www.tripadvisor.com/Attraction_Review-g60763-d104365-Reviews-Empire_State_Building-New_York_City_New_York.html"],
  "maxItems": 15,
  "placeType": "restaurant",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Use cases

- **Travel planning** — pull a shortlist of top-ranked hotels or restaurants for a destination into your own itinerary tool
- **Competitive benchmarking for hospitality** — compare your property's rating and ranking against nearby competitors
- **Local business directories** — populate a city guide with contact details and ratings for attractions and restaurants
- **Market research** — track how many hotels or restaurants a city has at each price level
- **Lead generation** — collect contact details for restaurants or attractions in a region for outreach

### FAQ

**Do I need a TripAdvisor account or API key?**
No. The actor reads TripAdvisor's publicly available place data; no login or API key is required.

**Do I need a proxy?**
Direct URLs (`startUrls`) work without one. For `searchQueries`, the actor automatically provisions a residential proxy if you don't supply your own, since TripAdvisor's search pages run into anti-bot protection more often than direct place pages.

**Why are some fields empty strings instead of missing?**
TripAdvisor doesn't publish every field for every place — a restaurant won't have `hotelClass`, and a hotel won't have `cuisine`. Rather than remove the field, the actor keeps it as an empty string so every record has the same columns.

**How many results come back per search query?**
Up to `maxItems` per query (100 at most). The actor reads only the first page of TripAdvisor's list for the destination, so a query usually yields a few dozen places at most, and places already returned for an earlier query or URL are not repeated. Places whose details can't be loaded are skipped.

**Why does `best restaurants London` return hotels too?**
The search phrase only identifies the destination. With `placeType` left at `all`, the actor reads London's overview page, which mixes place types. Set `placeType` to `restaurant` to get only restaurants.

**What's the difference between `rankingPosition` and `rankingString`?**
`rankingPosition` is just the number (e.g. `20`); `rankingString` is TripAdvisor's full ranking sentence (e.g. `#20 of 583 hotels in New York City`).

**Can I filter search results to only one place type?**
Yes, set `placeType` to `hotel`, `restaurant`, or `attraction`. It only applies to `searchQueries`, not to places added via `startUrls`. If TripAdvisor's list page for the destination can't be read, the actor falls back to TripAdvisor's search suggestions, which return fewer places.

**Is this affiliated with TripAdvisor?**
No. This is an independent, third-party actor that reads TripAdvisor's publicly available place data; it is not affiliated with or endorsed by TripAdvisor.

# Actor input Schema

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

Search terms to find places on TripAdvisor. Examples: 'hotels in Paris', 'best restaurants NYC', 'attractions London'.

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

Direct TripAdvisor place URLs (Hotel_Review, Restaurant_Review, Attraction_Review pages).

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

Maximum number of places to return per search query.

## `placeType` (type: `string`):

Filter search results by place type.

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

Proxy settings. Residential proxy recommended for search queries. Not needed for direct URLs.

## Actor input object example

```json
{
  "searchQueries": [
    "hotels in New York"
  ],
  "maxItems": 50,
  "placeType": "all"
}
```

# Actor output Schema

## `locationId` (type: `string`):

TripAdvisor location identifier

## `name` (type: `string`):

Place name

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

Place type (hotel, restaurant, attraction)

## `subcategory` (type: `string`):

Specific subcategory label

## `address` (type: `string`):

Complete address string

## `street` (type: `string`):

Street address

## `city` (type: `string`):

City name

## `state` (type: `string`):

State or province

## `country` (type: `string`):

Country name

## `postalCode` (type: `string`):

Postal or ZIP code

## `latitude` (type: `string`):

Geographic latitude

## `longitude` (type: `string`):

Geographic longitude

## `rating` (type: `string`):

Overall rating (0-5)

## `numberOfReviews` (type: `string`):

Total review count

## `rankingPosition` (type: `string`):

Numerical rank in location

## `rankingString` (type: `string`):

Full ranking text

## `priceLevel` (type: `string`):

Price level symbols (e.g. $$$$)

## `priceRange` (type: `string`):

Price range text

## `phone` (type: `string`):

Phone number

## `email` (type: `string`):

Email address

## `website` (type: `string`):

Official website URL

## `hotelClass` (type: `string`):

Hotel star rating (hotels only)

## `cuisine` (type: `string`):

Cuisine types (restaurants only)

## `hours` (type: `string`):

Operating hours

## `description` (type: `string`):

Place description

## `neighborhoods` (type: `string`):

Neighborhood names

## `webUrl` (type: `string`):

TripAdvisor page URL

## `isClosed` (type: `string`):

Whether the place is permanently closed

## `photoUrl` (type: `string`):

Main photo URL

## `searchQuery` (type: `string`):

The search query that found this place

## `scrapeTimestamp` (type: `string`):

ISO timestamp of when the data was scraped

# 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 = {
    "searchQueries": [
        "hotels in New York"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/tripadvisor-hotel-restaurant-and-attraction-finder").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 = {
    "searchQueries": ["hotels in New York"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/tripadvisor-hotel-restaurant-and-attraction-finder").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 '{
  "searchQueries": [
    "hotels in New York"
  ],
  "maxItems": 50
}' |
apify call nimbryxo-studio/tripadvisor-hotel-restaurant-and-attraction-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/tripadvisor-hotel-restaurant-and-attraction-finder"
        }
    }
}
```

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/sv4kVnROMGAakFpbJ/builds/hALt0wCXSINw1JNf1/openapi.json