# GetYourGuide Reviews Scraper (`automation-lab/getyourguide-reviews-scraper`) Actor

⭐ Export individual GetYourGuide reviews with ratings, reviewer context, dates, verified-booking markers, review text, and activity metadata for recurring reputation monitoring.

- **URL**: https://apify.com/automation-lab/getyourguide-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Export individual public customer reviews from GetYourGuide activity pages.

Get structured ratings, reviewer names and countries, review dates, verified-booking markers, review text, activity providers, and aggregate rating context without copying reviews by hand.

Use the dataset for tour reputation monitoring, destination research, competitor benchmarking, sentiment analysis, and recurring review alerts.

### What does GetYourGuide Reviews Scraper do?

GetYourGuide Reviews Scraper opens the public review panel for each activity URL you provide and saves one dataset item per customer review.

It can:

- 🎟️ process one or many GetYourGuide activity pages;
- ⭐ collect the review rating and review text;
- 🌍 capture reviewer country when GetYourGuide exposes it;
- ✅ identify verified bookings;
- 🗓️ filter out reviews older than a chosen date;
- 🧭 repeat activity title, provider, and overall rating context on every row;
- 🔁 generate stable review IDs for recurring monitoring;
- 📦 export results as JSON, CSV, Excel, XML, or RSS through Apify.

The Actor uses GetYourGuide's public review-data route through a conservative residential session because GetYourGuide challenges ordinary direct requests.

### Who is it for?

#### Tour and activity operators

Track what travelers say about your activities, guides, meeting points, queues, value, and service quality.

#### Destination marketing teams

Compare traveler feedback across attractions and experiences in a city or region.

#### Travel agencies and marketplaces

Enrich internal activity catalogs with current public review evidence and rating context.

#### Reputation and customer-experience teams

Schedule exports, detect new complaints, and route review text into sentiment or topic-classification workflows.

#### Researchers and analysts

Build reproducible review datasets without manually paging through GetYourGuide.

### Why use this GetYourGuide review extractor?

Manual review collection is slow and inconsistent. Activity pages can contain thousands of reviews, and repeated monitoring makes copy-and-paste workflows impractical.

This Actor provides:

- consistent field names across activities;
- strict validation for GetYourGuide activity URLs;
- review-level deduplication within each run;
- bounded residential-session retries instead of silent empty success;
- global and per-activity result limits;
- source URLs on every record for traceability;
- direct integration with Apify datasets, schedules, webhooks, API clients, and MCP.

### What GetYourGuide review data can I extract?

| Field | Description |
|---|---|
| `reviewId` | Public GetYourGuide review identifier |
| `activityId` | Numeric GetYourGuide product/activity ID |
| `activityUrl` | Canonical public activity URL |
| `activityTitle` | Activity title |
| `activityProvider` | Supplier shown on the activity page |
| `aggregateRating` | Overall activity rating |
| `aggregateReviewCount` | Total review count shown by GetYourGuide |
| `rating` | Individual review score |
| `reviewerName` | Public reviewer display name |
| `reviewerCountry` | Public reviewer country, when shown |
| `travelerType` | Couple, family, solo, or group context when shown |
| `reviewDate` | Review date in `YYYY-MM-DD` form when parseable |
| `verifiedBooking` | Whether the page marks the review as verified |
| `reviewText` | Full rendered review text |
| `helpfulCount` | Helpful-vote count when exposed |
| `language` | Page locale requested by the run |
| `mediaUrls` | Review media URLs when exposed |
| `scrapedAt` | UTC extraction timestamp |

Optional fields are omitted when they are not present on the public page.

### How to scrape GetYourGuide reviews

1. Open a public GetYourGuide activity page.
2. Copy the URL containing a segment such as `-t149861`.
3. Paste the URL into **GetYourGuide activity URLs**.
4. Set a small **Maximum reviews per activity** for your first run.
5. Optionally add an **Earliest review date**.
6. Click **Start**.
7. Open the default dataset to preview, filter, or export the records.

For recurring monitoring, save the configuration as a task and attach an Apify schedule.

### Input

Example input:

```json
{
  "startUrls": [
    {
      "url": "https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/"
    }
  ],
  "maxReviewsPerUrl": 20,
  "maxItems": 50,
  "cutoffDate": "2026-01-01",
  "language": "en-US"
}
````

#### Input fields

| Field | Type | Default | Notes |
|---|---|---:|---|
| `startUrls` | array | required | Public activity detail URLs only |
| `maxReviewsPerUrl` | integer | `20` | Cap for each activity |
| `maxItems` | integer | `50` | Global cap across all activities |
| `cutoffDate` | string | empty | Optional ISO date |
| `language` | string | `en-US` | Locale such as `en-US` or `de-DE` |
| `proxyConfiguration` | object | Residential US | Advanced network configuration |

Search pages, destination pages, and URLs on other domains fail validation before a browser is opened.

### Output example

```json
{
  "reviewId": "dc2023770542bc5a773bbf4d",
  "activityId": "149861",
  "activityUrl": "https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/",
  "activityTitle": "Paris: Eiffel Tower Entry Ticket with Optional Summit Access",
  "activityProvider": "Global Tours And Tickets",
  "aggregateRating": 4.5,
  "aggregateReviewCount": 22038,
  "rating": 5,
  "reviewerName": "Fiona",
  "reviewerCountry": "Australia",
  "reviewDate": "2026-07-18",
  "verifiedBooking": true,
  "reviewText": "Our tour guide Sabrina was excellent...",
  "language": "en-US",
  "scrapedAt": "2026-07-22T09:14:44.421Z"
}
```

Every output row is independently useful in CSV and spreadsheet exports because it contains both review and activity context.

### How much does it cost to scrape GetYourGuide reviews?

The Actor uses pay-per-event pricing:

- one small **Start** charge per run;
- one **Review extracted** charge for each saved dataset item;
- automatic volume discounts by Apify subscription tier.

The current one-time start price is **$0.001**. Per-review prices are **$0.0043588 FREE**, **$0.0037903 BRONZE**, **$0.0029564 SILVER**, **$0.0022742 GOLD**, **$0.0015161 PLATINUM**, and **$0.0010613 DIAMOND**. A small 10-review prefilled run is designed as a low-cost first test.

Residential proxy and Actor compute are included in the metered operation; you do not need a separate scraping server.

### Review limits and pagination

`maxReviewsPerUrl` limits each activity independently.

`maxItems` limits the entire run. The global cap always wins when it is reached first.

The Actor follows the same public review pagination contract used by **See more reviews** until it reaches the requested cap, the source stops exposing additional records, or the date filter excludes records.

GetYourGuide can vary how many reviews are rendered in each batch. Do not assume a fixed page size.

### Date filtering for review monitoring

Set `cutoffDate` to an ISO date such as `2026-07-01` to omit older reviews.

A useful scheduled workflow is:

1. run the Actor daily or weekly;
2. use a recent cutoff date;
3. deduplicate downstream by `reviewId`;
4. send only unseen IDs to Slack, email, a database, or a sentiment model.

The stable ID comes from GetYourGuide's public review record.

### Multiple activity URLs

Add several activity detail URLs to compare products or monitor a portfolio.

Sources are processed sequentially to keep the protected review API session conservative. If one activity fails, the Actor logs the failure and continues to the next source.

The run fails when no useful review record can be produced. This prevents a challenge page from becoming a misleading successful empty export.

### Tips for reliable runs

- Start with 10–20 reviews from one activity.
- Keep Residential proxy enabled.
- Use canonical activity detail URLs with `-t<activityId>`.
- Avoid very large first runs before confirming the activity has public reviews.
- Use `maxItems` as a cost-control ceiling.
- Inspect the run log when a source reports a challenge.
- Schedule moderate recurring exports instead of repeatedly requesting an entire review history.

### GetYourGuide page changes and limitations

GetYourGuide is a dynamic website and may change labels, review layouts, or anti-bot controls.

The Actor only exports fields rendered anonymously on the public activity page. It does not access private traveler profiles, booking accounts, supplier dashboards, or partner credentials.

Some reviews do not expose traveler type, media, helpful counts, or language metadata. Those optional keys may be absent.

The visible page may translate interface labels or review content according to locale and GetYourGuide behavior.

Deleted or edited reviews can cause a record to disappear or receive a different stable ID on a later run.

### Integrations

#### Google Sheets or Excel

Export CSV/XLSX from the dataset, or connect an Apify integration to refresh an analysis sheet.

#### Slack and Microsoft Teams alerts

Use a run-finished webhook, filter unseen `reviewId` values, and post low-rating reviews to an operations channel.

#### Sentiment and topic analysis

Send `reviewText`, `rating`, and `activityId` to a classifier or LLM. Group comments into themes such as guide quality, queues, meeting points, value, and accessibility.

#### Data warehouses

Load dataset items into BigQuery, Snowflake, PostgreSQL, or another warehouse through API clients or automation tools.

#### Zapier and Make

Trigger the Actor on a schedule and route new records to CRM, ticketing, or notification workflows.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/getyourguide-reviews-scraper').call({
  startUrls: [
    { url: 'https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/' }
  ],
  maxReviewsPerUrl: 20,
  maxItems: 20,
  language: 'en-US'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/getyourguide-reviews-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/'
    }],
    'maxReviewsPerUrl': 20,
    'maxItems': 20,
    'language': 'en-US',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~getyourguide-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{
      "url": "https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/"
    }],
    "maxReviewsPerUrl": 10,
    "maxItems": 10
  }'
```

Poll the returned run ID, then read items from its `defaultDatasetId`.

### Use GetYourGuide Reviews Scraper with MCP

Connect Apify Actors to Claude and other MCP clients through:

`https://mcp.apify.com/?tools=automation-lab/getyourguide-reviews-scraper`

Example prompts:

- “Run the GetYourGuide reviews scraper for this activity and summarize complaints.”
- “Export 20 public reviews and group feedback by traveler country.”
- “Compare recurring themes across these three GetYourGuide activity URLs.”
- “Find low-rating verified reviews since the start of this month.”

#### Claude Desktop configuration

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/getyourguide-reviews-scraper"
    }
  }
}
```

#### Claude Code

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com/?tools=automation-lab/getyourguide-reviews-scraper'
```

#### Cursor setup

Add the same Apify MCP URL as a remote MCP server in **Cursor Settings → Tools & MCP**. Name the server `apify` and enable the GetYourGuide Reviews Scraper tool.

#### VS Code setup

Add the remote Apify MCP URL to your VS Code MCP server configuration, start the server, and select `automation-lab/getyourguide-reviews-scraper` from the available tools.

### Scheduling a reputation monitor

Create an Apify task with activity URLs and a bounded recent-review limit.

Attach a daily or weekly schedule. Store review IDs in your downstream system and act only on unseen records.

For a support workflow, add a webhook that sends low ratings to a queue. For market research, append every run to a warehouse and build trends by activity, provider, country, and rating.

### Is it legal to scrape GetYourGuide reviews?

This Actor extracts information displayed anonymously on public activity pages.

You are responsible for your use case. Review GetYourGuide's terms, applicable database and copyright rules, privacy law, and your organization's data-retention policies.

Do not use the data to harass reviewers, infer sensitive traits, build private profiles, or republish protected text without a lawful basis.

Collect only what you need, secure exported datasets, and honor valid deletion or access requests where applicable.

This page is product documentation, not legal advice.

### Troubleshooting

#### “Only getyourguide.com URLs are supported”

Use a public URL on `getyourguide.com`, not a copied tracking redirect or another travel site.

#### “Expected a GetYourGuide activity detail URL”

The path must contain an activity ID such as `-t149861`. Search and city pages are not review sources.

#### “Activity page was blocked”

Keep the Residential proxy configuration enabled and retry later. Do not replace it with a direct connection unless you have tested that route.

#### The run returned fewer reviews than requested

The activity may expose fewer public reviews, the date filter may exclude older records, or the review panel may have stopped offering another batch. Check the source page and run log.

#### An optional output field is missing

GetYourGuide does not show every field on every review. Optional fields are omitted rather than filled with invented values.

### Frequently asked questions

#### Does it require a GetYourGuide login?

No. The supported scope is the individual review data rendered on public activity pages.

#### Can I scrape destination search results?

Not with this Actor. Use [GetYourGuide Activities Scraper](https://apify.com/automation-lab/getyourguide-activities-scraper) to discover activity listings, then send selected activity detail URLs here.

#### Can I monitor several tours?

Yes. Add multiple activity URLs and set both per-URL and global limits.

#### Are reviews deduplicated?

Yes, within a run. Use `reviewId` for deduplication across scheduled runs.

#### Does it translate reviews?

The Actor records what the public page renders in the requested locale. It does not promise an independent translation service.

#### Can I export CSV or Excel?

Yes. Open the default dataset and choose your preferred export format.

### Related travel scrapers

- [GetYourGuide Activities Scraper](https://apify.com/automation-lab/getyourguide-activities-scraper) — discover activities, prices, ratings, and listing URLs.
- [Klook Reviews Scraper](https://apify.com/automation-lab/klook-reviews-scraper) — export public Klook activity and hotel reviews.
- [Booking Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper) — collect public accommodation review data.
- [Hostelworld Guest Reviews Scraper](https://apify.com/automation-lab/hostelworld-guest-reviews-scraper) — analyze hostel guest feedback.

Combine an activity discovery Actor with this review Actor for destination-level competitive intelligence.

### Support

If a valid activity URL fails repeatedly, open an issue from the Actor page and include:

- the public activity URL;
- a run ID;
- the approximate time of failure;
- the expected number of reviews;
- any non-default locale or proxy settings.

Do not include account credentials or private booking information.

# Actor input Schema

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

Activity pages whose individual customer reviews should be exported. Search and destination pages are not accepted.

## `maxReviewsPerUrl` (type: `integer`):

Stop after this many unique reviews from each activity URL.

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

Global cap across all activity URLs.

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

Optional ISO date such as 2026-01-01. Older reviews are excluded.

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

Browser locale used for GetYourGuide labels and review dates.

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

Residential proxy is recommended because GetYourGuide challenges direct and datacenter traffic.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/"
    }
  ],
  "maxReviewsPerUrl": 10,
  "maxItems": 10,
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Open the default dataset overview containing one typed item per extracted customer review.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/"
        }
    ],
    "maxReviewsPerUrl": 10,
    "maxItems": 10,
    "language": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "startUrls": [{ "url": "https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/" }],
    "maxReviewsPerUrl": 10,
    "maxItems": 10,
    "language": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "startUrls": [
    {
      "url": "https://www.getyourguide.com/paris-l16/paris-eiffel-tower-entry-ticket-with-optional-summit-access-t149861/"
    }
  ],
  "maxReviewsPerUrl": 10,
  "maxItems": 10,
  "language": "en-US"
}' |
apify call automation-lab/getyourguide-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GetYourGuide Reviews Scraper",
        "description": "⭐ Export individual GetYourGuide reviews with ratings, reviewer context, dates, verified-booking markers, review text, and activity metadata for recurring reputation monitoring.",
        "version": "0.1",
        "x-build-id": "wwxMVkDB6FmnbnCgy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~getyourguide-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~getyourguide-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~getyourguide-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "GetYourGuide activity URLs",
                        "type": "array",
                        "description": "Activity pages whose individual customer reviews should be exported. Search and destination pages are not accepted.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviewsPerUrl": {
                        "title": "Maximum reviews per activity",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many unique reviews from each activity URL.",
                        "default": 20
                    },
                    "maxItems": {
                        "title": "Maximum total reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Global cap across all activity URLs.",
                        "default": 50
                    },
                    "cutoffDate": {
                        "title": "Earliest review date",
                        "type": "string",
                        "description": "Optional ISO date such as 2026-01-01. Older reviews are excluded."
                    },
                    "language": {
                        "title": "Page language",
                        "type": "string",
                        "description": "Browser locale used for GetYourGuide labels and review dates.",
                        "default": "en-US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended because GetYourGuide challenges direct and datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
