# GetYourGuide Scraper — Tours, Activities & Attraction Tickets (`studio-amba/getyourguide-scraper`) Actor

Scrape tours, activities, and attraction tickets from getyourguide.com search results. Extract titles, locations, durations, ratings, review counts, and prices for any destination or activity keyword. No partner API credentials required.

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

## Pricing

from $2.00 / 1,000 result 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 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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Scrape tours, activities, and attraction tickets from [getyourguide.com](https://www.getyourguide.com) search results — titles, locations, durations, ratings, review counts, and prices for any destination or activity keyword.

### Why use this actor?

GetYourGuide is one of the largest tours-and-activities marketplaces in the world, listing tens of thousands of bookable experiences across nearly every city on earth. There's no public partner API without a business relationship with GetYourGuide, so pulling this data at scale otherwise means either signing a partner agreement or scraping the site directly. This actor does the latter: it runs the same search a visitor would, parses the server-rendered result cards, and returns structured data — no partner credentials, no login.

Typical uses:

- Competitive pricing research for tour operators and travel agencies
- Building a meta-search or comparison site for activities in a destination
- Market research on what activities exist, how they're priced, and how they're rated in a given city
- Feeding activity data into a travel itinerary tool or recommendation engine

### How it works

GetYourGuide is protected by Cloudflare, so a plain HTTP request gets a 403 and a bot-challenge cookie. This actor routes every page fetch through Bright Data's Web Unlocker API, which handles the Cloudflare challenge and returns clean HTML. The actor then parses that HTML with Cheerio — no browser, no Playwright, just a lightweight fetch-and-parse loop, which keeps runs fast and cheap.

GetYourGuide serves at least two different result-card layouts for the same query (observed live during development) — one with a dedicated "location" element, one without. The actor tries both layouts for every field and falls back to deriving the location from the activity's URL slug when no dedicated element exists, so field coverage stays high regardless of which layout a given request happens to get.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `searchQuery` | String | No (default: `rome`) | Activity or destination to search for — a city name (e.g. `rome`, `paris`, `barcelona`) or an activity keyword (e.g. `cooking class`, `wine tasting`). |
| `maxResults` | Integer | No (default: `100`) | Maximum number of activities to return. The actor pages through search results (`?p=2`, `?p=3`, ...) until it hits this limit or runs out of results. |
| `brightDataApiKey` | String (secret) | No\* | Your Bright Data API key for the Web Unlocker zone. \*Optional if the `BRIGHT_DATA_API_KEY` environment variable is already set on the actor version — in that case you can leave this blank and every run uses the shared key. |
| `proxyConfiguration` | Object | No | Present for input-schema completeness. Page fetches actually go through the Bright Data Web Unlocker API, not through Apify's proxy, so this field has no effect on how requests are routed. |

Example input:

```json
{
  "searchQuery": "rome",
  "maxResults": 20,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

Empty input (`{}`) also works — it falls back to `searchQuery: "rome"` and `maxResults: 100`, as long as a Bright Data key is available via input or the environment variable.

### Output

Each item in the dataset represents one activity from a search results page.

| Field | Type | Description |
|---|---|---|
| `activityTitle` | String | Name of the tour, activity, or ticket |
| `location` | String | City or destination where the activity takes place |
| `duration` | String (nullable) | Duration of the activity, e.g. `"2.5 hours"` |
| `rating` | Number (nullable) | Average customer rating, 0–5 scale |
| `reviewCount` | Integer (nullable) | Number of customer reviews |
| `price` | Number | Starting ("from") price for the activity |
| `currency` | String | Currency code for the price, e.g. `EUR` |
| `url` | String | Full activity page URL |
| `scrapedAt` | String | ISO 8601 timestamp of when the item was scraped |

Example output item:

```json
{
  "activityTitle": "Colosseum, Roman Forum & Palatine Hill Guided Tour",
  "location": "Rome",
  "duration": "2.5 hours",
  "rating": 4.8,
  "reviewCount": 86247,
  "price": 49,
  "currency": "EUR",
  "url": "https://www.getyourguide.com/rome-l33/colosseum-roman-forum-palatine-hill-guided-tour-t195566/",
  "scrapedAt": "2026-07-13T01:08:13.706Z"
}
```

### How to scrape GetYourGuide data

To pull activity data for a destination, set `searchQuery` to a city name (e.g. `"rome"`, `"lisbon"`, `"kyoto"`) or an activity type (e.g. `"food tour"`, `"scuba diving"`), and set `maxResults` to how many activities you want back. The actor:

1. Requests `https://www.getyourguide.com/s/?q=<query>&p=<page>` through the Bright Data Web Unlocker API, which handles GetYourGuide's Cloudflare protection.
2. Parses the server-rendered result cards (`data-test-id="verticalActivityCard"`) with Cheerio, extracting title, location, duration, rating, review count, and starting price for each card.
3. Increments the `p` query parameter to move through pages (24 results per page) until `maxResults` is reached or a page returns no cards.
4. Pushes each activity to the dataset as it's found, so partial results are available even if a run is stopped early.

This gets you a clean, structured feed of what's bookable for a destination or activity type — useful for tracking price changes over time, benchmarking a competitor's offerings, or building a dataset of activities for a downstream tool.

### Cost estimate

This actor uses Bright Data's Web Unlocker (billed separately, roughly $1.5 per 1,000 successful requests at time of writing) for each search page fetch. A page returns up to 24 activities, so:

- 100 results ≈ 5 page fetches ≈ under a cent of Bright Data cost
- 1,000 results ≈ 42 page fetches ≈ a few cents of Bright Data cost

Actor compute cost is minimal — no browser is launched, each run is a short-lived Node.js process doing HTTP fetch + HTML parsing.

### Limitations

- **Requires a Bright Data Web Unlocker API key.** GetYourGuide is behind Cloudflare; without a working key, every request returns a 403 challenge page and the actor fails with zero items.
- **Search-page data only.** This actor parses the search results page, not individual activity detail pages — so fields like a full itinerary, cancellation policy, or all available time slots aren't included. If you need that, you'd fetch the activity's own `url` separately.
- **No partner API used.** GetYourGuide has an official partner API for approved travel businesses, but it requires a commercial agreement. This actor does not use it — it works entirely from public search results, so field availability depends on what GetYourGuide chooses to render on the search page (and that has changed at least once already during development, see "How it works" above).
- **Best-effort fields.** `rating`, `reviewCount`, and `duration` are not shown on every card (e.g. new listings with no reviews yet), so these fields may be missing on a small share of items. `activityTitle`, `location`, `price`, `currency`, and `url` are present on effectively every item.

### Related Scrapers

- [Tiqets Scraper](https://apify.com/studio-amba/tiqets-scraper) — attraction tickets and tours from tiqets.com, GetYourGuide's closest direct competitor
- [BlaBlaCar Scraper](https://apify.com/studio-amba/blablacar-scraper) — carpool and bus trip search results, useful for the transport leg of a trip alongside activities
- [Touring Scraper](https://apify.com/studio-amba/touring-scraper) — Belgian automobile club travel guides, FAQs, and cross-border travel information

### Support

Found a bug or have a feature request? Open an issue on the actor's Apify Store page or reach out through the Apify platform's contact options.

# Actor input Schema

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

Activity or destination to search for (e.g. a city name like 'rome' or an activity like 'cooking class').

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

Maximum number of activities to return.

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

Your Bright Data API key for the Web Unlocker zone. Required to bypass GetYourGuide's Cloudflare protection. Optional if the BRIGHT\_DATA\_API\_KEY environment variable is set on the actor version. Get a key at https://brightdata.com

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

Present for schema compatibility. Page fetches actually go through the Bright Data Web Unlocker API (see brightDataApiKey), not through this proxy configuration.

## Actor input object example

```json
{
  "searchQuery": "rome",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQuery": "rome",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "searchQuery": "rome",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/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 '{
  "searchQuery": "rome",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/getyourguide-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2fpc1ZD7aWx6Nm8Ul/builds/VID0KYl6yDvD0HbmF/openapi.json