# Getyourguide Reviews Scraper (`stealth_mode/getyourguide-reviews-scraper`) Actor

Scrape detailed tour reviews from GetYourGuide.com by Tour ID. Collect ratings, author info, traveler types, media, replies, and 20+ fields per review — perfect for tour operators, travel analysts, and reputation managers.

- **URL**: https://apify.com/stealth\_mode/getyourguide-reviews-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## GetYourGuide Reviews Scraper: Extract Tour Reviews at Scale

---

### What Is GetYourGuide.com?

GetYourGuide is one of the world's largest online marketplaces for tours, activities, and travel experiences, hosting millions of verified customer reviews across hundreds of thousands of listings. These reviews are a goldmine of sentiment data, quality signals, and traveler insights — but collecting them manually is impractical at any meaningful scale.

The **GetYourGuide Reviews Scraper** solves this by automating review extraction for any tour, using only its Tour ID. Whether you manage a single experience or a large portfolio of activities, this scraper delivers structured, analysis-ready review data without writing a single line of code.

---

### Overview

The **GetYourGuide Reviews Scraper** targets the review section of individual tour pages on GetYourGuide.com. It retrieves full review records including ratings, written feedback, author metadata, traveler type, media attachments, and operator replies.

Designed for:

- **Tour operators** monitoring guest satisfaction and responding to trends
- **Travel analysts** building sentiment datasets across destinations or categories
- **Reputation managers** tracking review volume, rating distribution, and language breakdown
- **Researchers** studying traveler behavior and experience quality in the tours & activities sector

Key advantages include pagination via `offset`, configurable item limits, and resilient handling of failures through `ignore_url_failures` — making it suitable for both quick spot-checks and large-scale data collection runs.

---

### Input Format

The scraper is configured via a JSON object. No URLs are required — just the Tour ID extracted from the GetYourGuide tour page URL.

```json
{
  "tour_id": "68846",
  "offset": 0,
  "max_items_per_url": 200,
  "ignore_url_failures": true
}
````

#### Field Definitions

| Field | Type | Description |
|---|---|---|
| `tour_id` | `string` | **Required.** The numeric Tour ID found in the tour's URL. Example: `/paris-l16/full-champagne-wine-day-tour-from-paris-t68846/` → `68846` (the number after `t`) |
| `offset` | `integer` | Starting position for pagination. Use `0` to begin from the first review. Increase to skip already-collected reviews in subsequent runs. Default: `0` |
| `max_items_per_url` | `integer` | Maximum number of reviews to collect per run. Default: `20`. Set higher (e.g., `200`) for comprehensive collection |
| `ignore_url_failures` | `boolean` | If `true`, the scraper continues running even if a request fails, rather than stopping the entire job. Recommended: `true` for bulk runs |

#### How to Find the Tour ID

Navigate to any GetYourGuide tour page. The Tour ID is the number following `t` at the end of the URL path:

```
https://www.getyourguide.com/paris-l16/full-champagne-wine-day-tour-from-paris-t68846/ -> Tour ID: 68846
```

> **Tip:** To collect all reviews for a popular tour, combine a high `max_items_per_url` value with paginated runs using the `offset` field — for example, run with `offset: 0`, then `offset: 200`, then `offset: 400`, and so on.

***

### Output Format

#### Sample Output Record

```json
{
  "id": 123682326,
  "author": {
    "country": "United States",
    "full_name": "Komal"
  },
  "title": "",
  "message": "The trip was excellent! We saw some beautiful picturesque landscapes, learned a lot about the process of making champagne and got to experience some amazing champagne and champagne houses. Our tour guide, Aurélien, was knowledgeable and very helpful.",
  "is_anonymous": false,
  "rating": 5,
  "created": "2026-05-18T05:26:37+02:00",
  "activity_id": 68846,
  "enjoyment": "",
  "formatted_message": null,
  "has_upvoted": false,
  "is_partner_review": false,
  "is_test_data": false,
  "language": "en",
  "media": [],
  "option_id": 97003,
  "ratings": [
    {
      "rating_type": "rating_guide",
      "rating_value": 5
    },
    {
      "rating_type": "rating_value",
      "rating_value": 5
    },
    {
      "rating_type": "rating_transport",
      "rating_value": 5
    },
    {
      "rating_type": "rating_overall",
      "rating_value": 5
    }
  ],
  "replies": [
    {
      "created_at": "2026-05-19T13:43:13+02:00",
      "id": 1068933,
      "language_code": "en",
      "text": "Dear Komal, Thank you so much for this kind feedback! We're so glad you enjoyed the landscapes, the champagne houses and learned so much about the champagne production, that's exactly the experience we love to share! We'll make sure to pass on your kind words to Aurélien, he'll be very happy to hear it. We hope to welcome you back! Kind regards, My WineDays Team"
    }
  ],
  "traveler_type": "couple",
  "from_url": "https://travelers-api.getyourguide.com/activities/68846/adp-reviews-highlighted?limit=100&offset=0&sort=recommended"
}
```

Each review returns a structured record with 20 fields covering identity, content, ratings, and metadata.

#### Review Identity

| Field | Meaning |
|---|---|
| `ID` | Unique internal identifier for the review |
| `Activity ID` | The GetYourGuide activity/tour this review belongs to |
| `Option ID` | The specific tour option or time slot the reviewer booked |
| `Is Test Data` | Flags whether this is a test or synthetic entry, not a real customer review |

#### Reviewer Information

| Field | Meaning |
|---|---|
| `Author` | Reviewer's display name and profile metadata |
| `Is Anonymous` | Whether the reviewer chose to hide their identity |
| `Traveler Type` | Self-reported traveler category (e.g., couple, family, solo) |
| `Language` | Language in which the review was written |

#### Review Content

| Field | Meaning |
|---|---|
| `Title` | Short headline of the review (if provided) |
| `Message` | Raw review text as submitted by the traveler |
| `Formatted Message` | Processed/rendered version of the review message, may include formatting |
| `Media` | Attached photos or videos uploaded by the reviewer |
| `Created` | Timestamp of when the review was submitted |

#### Ratings & Sentiment

| Field | Meaning |
|---|---|
| `Rating` | Overall numeric rating given by the reviewer (typically 1–5) |
| `Ratings` | Breakdown of sub-ratings (e.g., value, guide quality, overall experience) where available |
| `Enjoyment` | Specific enjoyment score if captured separately from the main rating |

#### Engagement & Status

| Field | Meaning |
|---|---|
| `Has Upvoted` | Whether the current user (or session) has upvoted this review |
| `Is Partner Review` | Whether the review was submitted via a GetYourGuide partner channel |
| `Replies` | Operator or platform responses to the review |

***

### How to Use

1. **Find your Tour ID** — Open the target GetYourGuide tour page and extract the number after `t` in the URL.
2. **Configure the input** — Set `tour_id`, adjust `max_items_per_url` based on how many reviews you need, and set `offset: 0` for a fresh run.
3. **Run the scraper** — Start the actor and monitor the progress log.
4. **Paginate if needed** — For tours with hundreds of reviews, re-run with incremented `offset` values to collect the full dataset.
5. **Export** — Download results as JSON, CSV, or Excel for use in dashboards, spreadsheets, or analytics tools.

**Common issues:**

- If no results are returned, double-check that the `tour_id` is correct and corresponds to an active listing.
- For tours with few reviews, set `max_items_per_url` to a lower value to avoid unnecessary processing.
- Keep `ignore_url_failures: true` enabled when running multiple tour IDs in sequence.

***

### Use Cases & Business Value

- **Reputation monitoring:** Track rating trends over time and flag sudden drops in satisfaction
- **Competitive benchmarking:** Compare review sentiment across similar tours in the same destination
- **Content analysis:** Use review text for NLP, keyword extraction, or sentiment classification
- **Product improvement:** Identify recurring complaints or praise across sub-ratings like guide quality or value
- **Marketing insights:** Surface authentic traveler quotes and top-rated experiences for promotional use

The GetYourGuide Reviews Scraper turns thousands of dispersed review pages into a single, queryable dataset — saving hours of manual collection and enabling insights that are otherwise impossible to surface at scale.

***

### Conclusion

The **GetYourGuide Reviews Scraper** is a practical, efficient tool for anyone who needs structured review data from GetYourGuide.com. With detailed 20-field output, flexible pagination, and simple Tour ID-based configuration, it fits seamlessly into research workflows, operator dashboards, and data pipelines. Run it today to turn traveler feedback into actionable intelligence.

# Actor input Schema

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

Enter Tour ID. For example, /paris-l16/full-champagne-wine-day-tour-from-paris-t68846/ -> 68846)

## `offset` (type: `integer`):

Offset to start from

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "tour_id": "68846",
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "tour_id": "68846",
    "offset": 0,
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/getyourguide-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 = {
    "tour_id": "68846",
    "offset": 0,
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/getyourguide-reviews-scraper").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 '{
  "tour_id": "68846",
  "offset": 0,
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/getyourguide-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Getyourguide Reviews Scraper",
        "description": "Scrape detailed tour reviews from GetYourGuide.com by Tour ID. Collect ratings, author info, traveler types, media, replies, and 20+ fields per review — perfect for tour operators, travel analysts, and reputation managers.",
        "version": "0.0",
        "x-build-id": "d1IMVjlwCfhzhEvfS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~getyourguide-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-getyourguide-reviews-scraper",
                "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/stealth_mode~getyourguide-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-getyourguide-reviews-scraper",
                "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/stealth_mode~getyourguide-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-getyourguide-reviews-scraper",
                "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",
                "properties": {
                    "tour_id": {
                        "title": "Tour ID (Tour ID on getyourguide.com tour review page url, e.g. /paris-l16/full-champagne-wine-day-tour-from-paris-t68846/ -> 68846)",
                        "type": "string",
                        "description": "Enter Tour ID. For example, /paris-l16/full-champagne-wine-day-tour-from-paris-t68846/ -> 68846)"
                    },
                    "offset": {
                        "title": "Offset",
                        "type": "integer",
                        "description": "Offset to start from"
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
