# GetYourGuide Scraper - Tours, Activities, Prices & Reviews (`scrapesage/getyourguide-scraper`) Actor

Scrape GetYourGuide tours & activities by search, destination URL or activity URL. Get title, price + discount, currency, rating, review count, supplier/operator, full location, images and reviews. Supplier intelligence, monitoring, no login, no key, no browser.

- **URL**: https://apify.com/scrapesage/getyourguide-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Travel, E-commerce, Automation
- **Stats:** 8 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 tour / activity scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 Scraper — Tours, Activities, Prices, Reviews & Supplier Leads

Extract **complete GetYourGuide tour & activity data** — the fields thin scrapers leave empty: **real "from" prices with the discount % and original price, the currency you ask for, average rating, full review count, the tour operator ("Activity provider"), the complete location breakdown (city, area, country, point of interest) and the full image gallery**. Optionally pull every activity's **reviews** and build a **supplier intelligence** table that shows which operators run the most tours and how they rate.

No login, no cookies, no browser — fast JSON-LD extraction with 99%+ reliability.

### Why this GetYourGuide scraper?

Most GetYourGuide scrapers only parse the search cards and return `null` for price, supplier, and location, or quote prices in a random currency based on the server IP. This actor reads each activity's structured data and ships the **richest dataset in the category**:

| Data | Typical scrapers | This actor |
|---|---|---|
| "From" price + currency you choose | partial / wrong currency | ✅ real price, your currency |
| Discount % + original price | ❌ | ✅ |
| Average rating + full review count | partial | ✅ |
| Embedded reviews (rating, text, author, date) | ❌ | ✅ opt-in |
| Supplier / tour operator name | ❌ | ✅ |
| Supplier intelligence (activities, avg rating, cities) | ❌ | ✅ opt-in |
| Full location: city, area, country, point of interest | ❌ city only | ✅ |
| Categories / themes | ❌ | ✅ |
| Free-cancellation & skip-the-line flags | ❌ | ✅ |
| Image gallery | partial | ✅ |
| Value score (0–100) per activity | ❌ | ✅ |
| Monitor mode — only new activities | ❌ | ✅ |

### Use cases

- **Travel market & pricing intelligence** — track "from" prices, discounts, ratings and review velocity for any destination: Rome, Paris, Tokyo, New York, Barcelona, Dubai, and thousands more. Schedule recurring runs to watch price moves.
- **Tour operator competitor analysis** — turn on supplier intelligence to see which operators dominate a city, how their catalogue rates, and where they operate.
- **Affiliate & travel content** — populate destination guides, comparison pages and newsletters with structured experiences (price, rating, duration, images) at scale.
- **OTA & metasearch catalogues** — feed booking platforms and aggregators with clean, deduplicated activity data including geo and categories.
- **Lead & partnership prospecting** — identify the highest-volume, best-rated operators (`supplierName`, supplier summary) as partnership or sales targets.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **GetYourGuide Scraper**, enter search queries (a city, attraction or theme) or paste GetYourGuide URLs, choose your currency, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchQueries": ["rome colosseum", "paris museum tickets"],
    "currency": "USD",
    "language": "en",
    "maxResults": 100,
    "maxResultsPerSearch": 60,
    "includeActivityDetails": true,
    "includeReviews": true,
    "maxReviewsPerActivity": 10,
    "deduplicateSuppliers": true,
    "minRating": 4,
    "monitorMode": false
}
````

- **searchQueries** — free-text searches (city, attraction, or theme). Each is crawled across the results pages.
- **locationUrls** — GetYourGuide destination URLs (`https://www.getyourguide.com/rome-l33/`) to crawl a whole "things to do" listing, paginated automatically.
- **activityUrls** — direct activity pages (`…-t<ID>/`) for the full record.
- **startUrls** — optional mixed list (search, destination or activity URLs), auto-classified.
- **currency** *(default USD)* — 3-letter ISO currency for prices; the actual currency returned is always recorded in `priceCurrency`.
- **language** *(default en)* — content language code.
- **includeActivityDetails** *(default true)* — fetch each activity's detail page for the rich record. Turn OFF for a fast, cheap listing-only crawl.
- **includeReviews** *(default false)* — output each activity's embedded reviews as separate records.
- **deduplicateSuppliers** *(default false)* — emit one summary record per unique tour operator seen in the run.
- **minRating / minReviews / minPrice / maxPrice / freeCancellationOnly** — filters.
- **monitorMode** *(default false)* — emit only activities not seen in previous runs (see below).

### Output

One record per activity (`type: "activity"`), plus optional `review` and `supplier` records:

```json
{
    "type": "activity",
    "source": "getyourguide",
    "activityId": "195566",
    "title": "Colosseum, Roman Forum & Palatine Hill Guided Tour",
    "url": "https://www.getyourguide.com/rome-l33/colosseum-roman-forum-palatine-hill-guided-tour-t195566/",
    "description": "Skip the line at the Colosseum and explore the Roman Forum and Palatine Hill with an expert guide…",
    "priceFrom": 58.9,
    "originalPrice": 73.6,
    "discountPercent": 20,
    "priceCurrency": "USD",
    "rating": 4.77,
    "reviewCount": 84524,
    "durationText": "3 hours",
    "freeCancellation": true,
    "skipTheLine": true,
    "categories": ["Guided tours", "Skip-the-line", "Cultural & historical tours"],
    "languagesNote": "English, Spanish, Italian",
    "city": "Rome",
    "cityId": 33,
    "area": "Central Italy",
    "country": "Italy",
    "countryId": 169011,
    "pointOfInterest": "Colosseum",
    "supplierName": "Crown Tours",
    "imageUrl": "https://cdn.getyourguide.com/img/tour/33cca66c19886c9f.jpeg/53.jpg",
    "images": ["https://cdn.getyourguide.com/img/tour/…", "…"],
    "score": 92,
    "searchQuery": "rome colosseum",
    "scrapedAt": "2026-06-15T12:00:00.000Z"
}
```

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily/weekly to track prices or discover newly listed tours in a destination; perfect for price monitoring and affiliate feeds.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (price-drop alert, CRM import, Slack notification) the moment a run finishes.

**Monitor mode** remembers the activity IDs returned in previous runs and emits only **new** ones next time. It is orthogonal to Apify Schedules — the schedule decides *when* a run happens, monitor mode decides *what's new* — so the two compose cleanly without conflict.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/getyourguide-scraper').call({
    searchQueries: ['barcelona sagrada familia'],
    currency: 'EUR',
    includeReviews: true,
    deduplicateSuppliers: true,
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} activities, reviews & suppliers`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new activities or price changes straight into your tools.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored destination lists new tours.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the top-rated Colosseum tours under €60 in Rome and list the operators" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **travel & experiences intelligence stack**:

- **[Airbnb Scraper](https://apify.com/scrapesage/airbnb-scraper)** — stays, prices, availability and market monitoring.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events, ticket prices and organizer leads.
- **[Meetup Scraper](https://apify.com/scrapesage/meetup-scraper)** — events, groups and organizer leads.
- **[Luma Scraper](https://apify.com/scrapesage/luma-scraper)** — lu.ma events and organizer leads.
- **[Sched Conference Scraper](https://apify.com/scrapesage/sched-conference-scraper)** — sessions, speakers and sponsors.
- **[Foodpanda Scraper](https://apify.com/scrapesage/foodpanda-scraper)** — restaurants, menus and local leads.
- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — who's advertising what, for travel ad intelligence.

### Tips

- **Currency**: always set `currency` (USD, EUR, GBP, AUD …). GetYourGuide otherwise quotes prices in the currency of the request IP. The currency actually returned is recorded in `priceCurrency`.
- **Breadth**: GetYourGuide search returns ~24 activities per page and destinations ~33. To exhaust a big city, raise `maxResultsPerSearch`, or add multiple focused `searchQueries` (e.g. "rome colosseum", "rome vatican", "rome food tour").
- **Cost control**: turn `includeActivityDetails` OFF for a fast, cheap listing-only crawl, then run details only on the activities you keep.
- **Monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to track only newly listed tours, or rerun the same search to catch price changes.

### FAQ

**How do I scrape GetYourGuide tours for a specific city?** Put the city (or "city + attraction") in `searchQueries`, or paste the destination URL from your browser into `locationUrls` (e.g. `https://www.getyourguide.com/rome-l33/`).

**Can I choose the price currency?** Yes — set `currency` to any 3-letter ISO code (USD, EUR, GBP, AUD …). The currency actually returned is recorded in `priceCurrency` so values are never ambiguous.

**Does it get reviews?** Yes — turn on `includeReviews` to output each activity's embedded reviews (rating, text, author, date) as separate records.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new tours or price changes automatically?** Create a [Schedule](https://docs.apify.com/platform/schedules) (e.g. daily) and turn on `monitorMode` to emit only newly listed activities, or rerun the same search to capture price moves; add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push updates downstream.

**A field is null — why?** Some activities genuinely don't publish a discount, a named supplier, or every location field. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

**Is scraping GetYourGuide legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and GetYourGuide's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

Free-text searches run against GetYourGuide — a city, attraction, or theme (e.g. "rome colosseum", "paris", "tokyo food tour"). Each query is crawled across the results pages up to the per-search limit.

## `locationUrls` (type: `array`):

GetYourGuide destination URLs to crawl their full "things to do" listing (e.g. https://www.getyourguide.com/rome-l33/). Paginated automatically. Paste the URL straight from your browser.

## `activityUrls` (type: `array`):

Direct GetYourGuide activity / tour page URLs (…-t<ID>/). Each is fetched for the full rich record.

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

Optional mixed list of GetYourGuide URLs — search pages (/s/?q=…), destination pages (…-l<ID>/) or activity pages (…-t<ID>/). Each is auto-classified.

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

3-letter ISO currency for prices (e.g. USD, EUR, GBP, AUD). GetYourGuide quotes prices in this currency; the actual currency returned is always recorded in priceCurrency.

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

Language code for content (e.g. en, de, es, fr, it). Defaults to English.

## `includeActivityDetails` (type: `boolean`):

Fetch each activity's detail page for the rich record (description, price + discount, rating, review count, supplier, location breakdown, images, embedded reviews). Turn OFF for a fast, cheap listing-only crawl (id, title, URL, thumbnail).

## `includeReviews` (type: `boolean`):

Also output the reviews embedded on each activity page (rating, text, author, date) as separate review records. Requires activity details ON.

## `maxReviewsPerActivity` (type: `integer`):

Cap on review records emitted per activity.

## `deduplicateSuppliers` (type: `boolean`):

Also emit one summary record per unique tour operator ("Activity provider") seen in the run — how many of their activities appeared, their average rating, total reviews and the cities/countries they operate in. Great for competitor tracking.

## `minRating` (type: `number`):

Only keep activities with at least this average rating (0–5). 0 = no filter.

## `minReviews` (type: `integer`):

Only keep activities with at least this many reviews. 0 = no filter.

## `minPrice` (type: `number`):

Only keep activities priced at or above this amount (in the chosen currency). 0 = no filter.

## `maxPrice` (type: `number`):

Only keep activities priced at or below this amount (in the chosen currency). 0 = no filter.

## `freeCancellationOnly` (type: `boolean`):

Only keep activities that offer free cancellation.

## `maxResults` (type: `integer`):

Global cap on the number of activities (or listings) scraped across all searches and locations.

## `maxResultsPerSearch` (type: `integer`):

Cap on activities pulled from each individual search query or destination listing.

## `monitorMode` (type: `boolean`):

Remember activity IDs returned in previous runs (in a named key-value store) and emit only NEW ones next time. Pair with an Apify Schedule to watch a destination or search for newly listed tours. The schedule decides WHEN to run; monitor mode decides WHAT is new.

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

Name of the key-value store that holds the monitor's memory. Use different names to track different searches independently. Lowercase letters, digits and hyphens only.

## `maxConcurrency` (type: `integer`):

How many pages to fetch in parallel.

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

Proxy settings. Apify Proxy (default) is recommended. GetYourGuide is served globally with no anti-bot, so the automatic datacenter pool works well.

## Actor input object example

```json
{
  "searchQueries": [
    "rome colosseum",
    "paris museum tickets"
  ],
  "locationUrls": [
    "https://www.getyourguide.com/rome-l33/"
  ],
  "activityUrls": [
    "https://www.getyourguide.com/rome-l33/colosseum-roman-forum-palatine-hill-guided-tour-t195566/"
  ],
  "currency": "USD",
  "language": "en",
  "includeActivityDetails": true,
  "includeReviews": false,
  "maxReviewsPerActivity": 10,
  "deduplicateSuppliers": false,
  "minRating": 0,
  "minReviews": 0,
  "minPrice": 0,
  "maxPrice": 0,
  "freeCancellationOnly": false,
  "maxResults": 100,
  "maxResultsPerSearch": 60,
  "monitorMode": false,
  "monitorStoreName": "getyourguide-monitor",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Activity rows carry the full tour profile — price, discount, rating, review count, supplier, location and images; review and supplier rows carry their own fields.

# 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": [
        "rome colosseum"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/getyourguide-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 = { "searchQueries": ["rome colosseum"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/getyourguide-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 '{
  "searchQueries": [
    "rome colosseum"
  ]
}' |
apify call scrapesage/getyourguide-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GetYourGuide Scraper - Tours, Activities, Prices & Reviews",
        "description": "Scrape GetYourGuide tours & activities by search, destination URL or activity URL. Get title, price + discount, currency, rating, review count, supplier/operator, full location, images and reviews. Supplier intelligence, monitoring, no login, no key, no browser.",
        "version": "0.1",
        "x-build-id": "hKLdgqtH56PuSMoWr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~getyourguide-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-getyourguide-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/scrapesage~getyourguide-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-getyourguide-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/scrapesage~getyourguide-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-getyourguide-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text searches run against GetYourGuide — a city, attraction, or theme (e.g. \"rome colosseum\", \"paris\", \"tokyo food tour\"). Each query is crawled across the results pages up to the per-search limit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationUrls": {
                        "title": "Destination / location URLs",
                        "type": "array",
                        "description": "GetYourGuide destination URLs to crawl their full \"things to do\" listing (e.g. https://www.getyourguide.com/rome-l33/). Paginated automatically. Paste the URL straight from your browser.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activityUrls": {
                        "title": "Activity URLs",
                        "type": "array",
                        "description": "Direct GetYourGuide activity / tour page URLs (…-t<ID>/). Each is fetched for the full rich record.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (mixed)",
                        "type": "array",
                        "description": "Optional mixed list of GetYourGuide URLs — search pages (/s/?q=…), destination pages (…-l<ID>/) or activity pages (…-t<ID>/). Each is auto-classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "3-letter ISO currency for prices (e.g. USD, EUR, GBP, AUD). GetYourGuide quotes prices in this currency; the actual currency returned is always recorded in priceCurrency.",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language / locale",
                        "type": "string",
                        "description": "Language code for content (e.g. en, de, es, fr, it). Defaults to English.",
                        "default": "en"
                    },
                    "includeActivityDetails": {
                        "title": "Include full activity details",
                        "type": "boolean",
                        "description": "Fetch each activity's detail page for the rich record (description, price + discount, rating, review count, supplier, location breakdown, images, embedded reviews). Turn OFF for a fast, cheap listing-only crawl (id, title, URL, thumbnail).",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Also output the reviews embedded on each activity page (rating, text, author, date) as separate review records. Requires activity details ON.",
                        "default": false
                    },
                    "maxReviewsPerActivity": {
                        "title": "Max reviews per activity",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Cap on review records emitted per activity.",
                        "default": 10
                    },
                    "deduplicateSuppliers": {
                        "title": "Supplier / operator intelligence",
                        "type": "boolean",
                        "description": "Also emit one summary record per unique tour operator (\"Activity provider\") seen in the run — how many of their activities appeared, their average rating, total reviews and the cities/countries they operate in. Great for competitor tracking.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep activities with at least this average rating (0–5). 0 = no filter.",
                        "default": 0
                    },
                    "minReviews": {
                        "title": "Minimum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep activities with at least this many reviews. 0 = no filter.",
                        "default": 0
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only keep activities priced at or above this amount (in the chosen currency). 0 = no filter.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only keep activities priced at or below this amount (in the chosen currency). 0 = no filter.",
                        "default": 0
                    },
                    "freeCancellationOnly": {
                        "title": "Free cancellation only",
                        "type": "boolean",
                        "description": "Only keep activities that offer free cancellation.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Global cap on the number of activities (or listings) scraped across all searches and locations.",
                        "default": 100
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search / location",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on activities pulled from each individual search query or destination listing.",
                        "default": 60
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new activities)",
                        "type": "boolean",
                        "description": "Remember activity IDs returned in previous runs (in a named key-value store) and emit only NEW ones next time. Pair with an Apify Schedule to watch a destination or search for newly listed tours. The schedule decides WHEN to run; monitor mode decides WHAT is new.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Name of the key-value store that holds the monitor's memory. Use different names to track different searches independently. Lowercase letters, digits and hyphens only.",
                        "default": "getyourguide-monitor"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many pages to fetch in parallel.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Apify Proxy (default) is recommended. GetYourGuide is served globally with no anti-bot, so the automatic datacenter pool works well.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
