# GetYourGuide Activities Scraper (`automation-lab/getyourguide-activities-scraper`) Actor

Export GetYourGuide tours and activities with prices, ratings, reviews, duration, badges, booking velocity, ranking, and canonical URLs.

- **URL**: https://apify.com/automation-lab/getyourguide-activities-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 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/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 Activities Scraper

Export public GetYourGuide tours and activities into clean, analysis-ready data.

Track what travelers see for a destination: ranking, prices, discounts, ratings, review totals, duration, experience attributes, badges, and recent booking signals.

Use one query for a quick market snapshot or schedule several destination searches as a repeatable tour-inventory monitor.

### What does GetYourGuide Activities Scraper do?

The Actor opens public GetYourGuide search and destination pages in a real browser and saves one dataset row per activity.

It supports:

- 🔎 destination or activity search queries
- 🔗 GetYourGuide search and destination URLs
- 💶 requested currency and browser locale
- 📦 global activity and per-source page limits
- 🛡️ Apify or custom proxy configuration
- 🧹 deduplication by stable GetYourGuide activity ID

The result is a tabular dataset ready for JSON, CSV, Excel, XML, RSS, or API export.

### Who is it for?

#### Tour and activity operators

Compare your products with competing experiences, spot price moves, and watch which products receive high-visibility badges.

#### Online travel agencies and affiliates

Build destination research feeds, shortlist popular activities, and keep links and commercial signals current.

#### Destination marketing teams

Measure the visible mix of attractions, tours, cruises, tickets, food experiences, and day trips in a city.

#### Travel market researchers

Monitor ranking, review momentum, price bands, and booking-velocity messages across destinations.

#### Data and growth teams

Feed repeatable GetYourGuide listing snapshots into warehouses, dashboards, alerts, and competitive-intelligence workflows.

### Why use this GetYourGuide scraper?

Manual destination comparison becomes slow as soon as you track more than one city or revisit prices every week.

This Actor provides:

- consistent columns across every activity
- numeric prices, ratings, and review counts
- the original card text for quality checks
- source URL and rank for every observation
- stable activity IDs for change tracking
- a timestamp for snapshot comparisons
- browser rendering for pages that reject plain HTTP requests

### What GetYourGuide data can I extract?

| Field | Type | Description |
|---|---|---|
| `activityId` | string | Stable ID parsed from the activity URL |
| `destination` | string | Destination or context shown on the card |
| `title` | string | Public activity title |
| `url` | URL | Canonical activity URL without tracking parameters |
| `sourceUrl` | URL | Search or destination page used |
| `rank` | number | Position in the collected output |
| `duration` | string or null | Duration text such as `2 hours` |
| `attributes` | string[] | Pickup, audio guide, group size, skip-the-line, and similar labels |
| `rating` | number or null | Visible rating |
| `reviewCount` | number or null | Visible review total |
| `price` | number or null | Current displayed price |
| `originalPrice` | number or null | Previous price when a discount is visible |
| `currency` | string or null | ISO-style currency code |
| `priceQualifier` | string or null | Text such as `From` or a per-group qualifier |
| `badges` | string[] | Top pick, likely to sell out, official ticket, and similar labels |
| `bookingVelocity` | string or null | Recent booking message when displayed |
| `imageUrl` | URL or null | Listing image URL |
| `rawText` | string | Full normalized card text |
| `scrapedAt` | date | UTC extraction timestamp |

Fields may be null when GetYourGuide does not display that value on a listing card.

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

The Actor uses pay-per-event pricing:

- a **$0.005 Start** charge for each run
- an **Item extracted** charge for each unique saved activity
- automatic volume discounts by Apify plan tier

| Apify tier | Price per activity |
|---|---:|
| Free | $0.022754 |
| Bronze | $0.019786 |
| Silver | $0.015433 |
| Gold | $0.011872 |
| Platinum | $0.0079146 |
| Diamond | $0.0055402 |

For example, 50 activities cost about **$1.14 on Free** or **$0.99 on Bronze**, including the start event. Pricing reflects the residential proxy bandwidth required for reliable rendered GetYourGuide listings. You can control spend with `maxItems` and `maxPages` before starting a run.

All platform compute and proxy costs are included in the event prices.

### Quick start

1. Open the Actor input form.
2. Keep the prefilled Paris query or add your own destination.
3. Set `maxItems` to a small number for the first run.
4. Choose a currency and browser language.
5. Keep the prefilled residential Apify Proxy enabled for reliable cloud access.
6. Click **Start**.
7. Open **Dataset** to preview or export activity rows.

### Input

A minimal query input:

```json
{
  "queries": ["Paris"],
  "maxItems": 20,
  "maxPages": 3,
  "language": "en-US",
  "currency": "EUR"
}
````

A destination URL input:

```json
{
  "startUrls": [
    { "url": "https://www.getyourguide.com/rome-l33/" }
  ],
  "maxItems": 40,
  "maxPages": 4,
  "language": "en-US",
  "currency": "EUR"
}
```

You can combine `startUrls` and `queries` in one run. Duplicate activities are saved once.

### Input reference

#### `startUrls`

Public GetYourGuide search or destination listing URLs.

URLs on other domains fail validation. Individual activity detail URLs are rejected because this Actor targets listing discovery and monitoring.

#### `queries`

Search phrases such as:

- `Paris`
- `Rome food tours`
- `London museums`
- `Barcelona sailing`

#### `maxItems`

Maximum unique activity rows across all sources. The default is intentionally small for an inexpensive first run.

#### `maxPages`

Maximum rendered listing batches or scrolls per source. Increase this only when you need deeper ranking coverage.

#### `language`

A BCP 47 browser locale such as `en-US`, `de-DE`, or `fr-FR`. Labels are saved as GetYourGuide renders them.

#### `currency`

A three-letter code such as `EUR`, `USD`, or `GBP`.

#### `proxyConfiguration`

Residential Apify Proxy or custom proxy settings. The residential default is based on local verification after datacenter traffic was challenged.

### Output example

```json
{
  "activityId": "199048",
  "destination": "Paris",
  "title": "Skip-the-Line Versailles Palace & Garden Tour with Transport",
  "url": "https://www.getyourguide.com/paris-l16/skip-the-line-versailles-palace-garden-tour-with-transport-t199048/",
  "sourceUrl": "https://www.getyourguide.com/s/?q=Paris&currency=EUR",
  "rank": 1,
  "duration": "3 - 3.5 hours",
  "attributes": ["Skip the line", "Private option available"],
  "rating": 4.6,
  "reviewCount": 1165,
  "price": 62,
  "originalPrice": null,
  "currency": "EUR",
  "priceQualifier": "From",
  "badges": ["Top pick"],
  "bookingVelocity": null,
  "imageUrl": "https://cdn.getyourguide.com/image/...jpeg",
  "rawText": "Top pick Paris Skip-the-Line Versailles...",
  "scrapedAt": "2026-07-16T03:00:00.000Z"
}
```

### Ranking and pagination

`rank` reflects the order in which qualifying cards are collected across the input sources.

GetYourGuide can personalize or change ranking based on availability, locale, currency, market, time, and its own ranking system. A scheduled snapshot is therefore more useful than treating one run as permanent truth.

The Actor scrolls the rendered listing and uses a visible show/load-more control when one exists. It stops at the earliest of:

- `maxItems`
- `maxPages` for a source
- no additional visible activities
- the end of all sources

### Price monitoring workflow

For repeat competitive pricing research:

1. Use the same query or destination URLs each run.
2. Keep language, currency, and proxy country stable.
3. Schedule the Actor daily or weekly.
4. Save each dataset to a warehouse or named storage.
5. Join snapshots on `activityId`.
6. Alert when `price`, `originalPrice`, `rank`, or `badges` changes.

Preserve `rawText` so analysts can inspect unusual qualifier or discount formats.

### Ranking and popularity workflow

Use these fields together:

- `rank` for visible placement
- `rating` for customer satisfaction
- `reviewCount` for accumulated proof
- `badges` for merchandising signals
- `bookingVelocity` for recent demand messages

A booking-velocity field is null when GetYourGuide does not show a recent-booking message. Null does not mean zero bookings.

### Tips for reliable results

- Start with 10–20 items while validating a new destination.
- Keep the default residential Apify Proxy enabled on cloud runs.
- Use a custom proxy only after verifying that it renders complete activity cards.
- Keep currency and locale stable across historical comparisons.
- Split very large destination portfolios into scheduled batches.
- Review `rawText` when a price qualifier looks unusual.
- Treat ranking as a time-specific observation.

### Integrations

#### Google Sheets and Excel

Export the dataset as CSV or Excel for destination, price-band, and badge analysis.

#### Webhooks

Trigger a webhook after each run, then compare the new dataset with the previous snapshot.

#### Make and Zapier

Start destination checks from a schedule and route discounted or newly badged activities into alerts.

#### BigQuery, Snowflake, and warehouses

Load JSON rows, key on `activityId`, and partition observations by `scrapedAt`.

#### Slack and email alerts

Notify a market manager when a tracked product changes rank, price, or sell-out badge.

### API usage

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/getyourguide-activities-scraper').call({
  queries: ['Paris', 'Rome'],
  maxItems: 50,
  maxPages: 4,
  language: 'en-US',
  currency: 'EUR'
});

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

### Run with the Apify API using Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/getyourguide-activities-scraper").call(run_input={
    "queries": ["Paris", "Rome"],
    "maxItems": 50,
    "maxPages": 4,
    "language": "en-US",
    "currency": "EUR",
})

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

### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~getyourguide-activities-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["Paris"],
    "maxItems": 20,
    "maxPages": 3,
    "language": "en-US",
    "currency": "EUR"
  }'
```

### Use with Apify MCP

Connect AI clients through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/getyourguide-activities-scraper).

#### Claude Code setup

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

#### Claude Desktop setup

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

#### Cursor setup

Add the same Apify MCP URL as a remote HTTP MCP server in **Cursor Settings → MCP**.

#### VS Code setup

Add the same remote HTTP endpoint to your VS Code MCP server configuration, then enable the `automation-lab/getyourguide-activities-scraper` tool.

Example prompts:

- “Collect 20 Paris GetYourGuide activities and summarize the price bands.”
- “Compare visible rating and review counts for Rome food tours.”
- “Find activities showing sell-out or recent-booking signals.”

### Proxy and anti-bot behavior

GetYourGuide can reject plain HTTP requests or traffic from challenged IPs. The Actor uses browser rendering, a warm session, a desktop browser profile, and conservative sequential navigation.

Images, fonts, media, and common analytics requests are blocked to reduce bandwidth. Image URLs remain available from the rendered card markup.

If a source is blocked:

1. confirm the default residential Apify Proxy is enabled;
2. rotate the residential session or choose a suitable proxy country;
3. use a proxy country consistent with the destination market;
4. reduce source and page counts;
5. inspect the log for the HTTP status and page title.

### Limitations

- GetYourGuide can change its page structure without notice.
- Results depend on public availability at run time.
- Ranking can vary by locale, currency, IP market, date, and personalization.
- Some cards omit reviews, previous prices, badges, or booking velocity.
- Currency requests are subject to what GetYourGuide renders for the selected market.
- This Actor does not extract private supplier data, availability calendars, checkout prices, or logged-in account data.
- Activity detail URLs are not accepted as listing sources.

### Legality

This Actor extracts publicly visible listing information. Whether a specific use is lawful depends on jurisdiction, purpose, volume, contract terms, and the data you combine with it.

You are responsible for:

- following applicable laws and GetYourGuide terms;
- avoiding collection of unnecessary personal data;
- respecting intellectual-property and database rights;
- using reasonable request volume;
- applying appropriate retention and security controls.

This documentation is not legal advice.

### FAQ

#### Can I scrape several destinations in one run?

Yes. Add multiple queries, multiple destination URLs, or both. `maxItems` applies globally.

#### Does it extract GetYourGuide reviews?

It saves the visible rating and review count from each listing card. It does not extract individual review text.

#### Why is `originalPrice` null?

GetYourGuide only displays an original price when the listing card shows a comparison or discount.

#### Why is `bookingVelocity` null?

Recent-booking text appears only on some cards and can change over time.

#### Why did the run produce no items?

Check that the input is a public GetYourGuide search/destination URL or query. Then enable Apify Proxy or select residential proxy access. Total extraction failure causes the run to fail instead of silently returning an empty successful dataset.

#### Why are rankings different from my browser?

Locale, currency, IP location, availability, time, and GetYourGuide ranking updates can all change ordering. Keep these inputs stable for comparisons.

#### Can I request USD prices?

Yes. Set `currency` to `USD`. Confirm the returned `currency` and `rawText`, because the visible market can affect rendering.

#### How do I avoid duplicates?

The Actor deduplicates by stable GetYourGuide activity ID across all sources in one run.

### Related travel scrapers

Combine this Actor with other Automation Lab travel datasets:

- [Booking Scraper](https://apify.com/automation-lab/booking-scraper) for hotel inventory and pricing research
- [Tripadvisor Scraper](https://apify.com/automation-lab/tripadvisor-scraper) for destination and attraction intelligence
- [Booking Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper) for accommodation review analysis
- [Trip.com Hotels Scraper](https://apify.com/automation-lab/trip-com-hotels-scraper) for cross-OTA hotel comparisons

### Support

If a valid public listing stops working, open an issue from the Actor page and include:

- the input with secrets removed;
- the run URL;
- the expected destination or query;
- whether a proxy was enabled;
- an example activity visible in your browser.

That evidence makes page-structure and access changes faster to diagnose.

# Actor input Schema

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

GetYourGuide search or destination listing URLs. Activity detail URLs are rejected.

## `queries` (type: `array`):

Destinations or activity searches, for example Paris, Rome food tours, or London museums.

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

Stop after saving this many unique activity listings across all inputs.

## `maxPages` (type: `integer`):

How many rendered listing batches/scrolls to process for each source.

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

BCP 47 browser locale used for rendered labels, for example en-US, de-DE, or fr-FR.

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

Three-letter currency code requested from GetYourGuide, for example EUR, USD, or GBP.

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

Residential Apify Proxy is the proven default because GetYourGuide blocks plain HTTP and datacenter traffic. Custom proxies are also supported.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.getyourguide.com/s/?q=Paris"
    }
  ],
  "queries": [
    "Paris"
  ],
  "maxItems": 20,
  "maxPages": 3,
  "language": "en-US",
  "currency": "EUR",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

# 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/s/?q=Paris"
        }
    ],
    "queries": [
        "Paris"
    ],
    "maxItems": 20,
    "maxPages": 3,
    "language": "en-US",
    "currency": "EUR"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/getyourguide-activities-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/s/?q=Paris" }],
    "queries": ["Paris"],
    "maxItems": 20,
    "maxPages": 3,
    "language": "en-US",
    "currency": "EUR",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/getyourguide-activities-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/s/?q=Paris"
    }
  ],
  "queries": [
    "Paris"
  ],
  "maxItems": 20,
  "maxPages": 3,
  "language": "en-US",
  "currency": "EUR"
}' |
apify call automation-lab/getyourguide-activities-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GetYourGuide Activities Scraper",
        "description": "Export GetYourGuide tours and activities with prices, ratings, reviews, duration, badges, booking velocity, ranking, and canonical URLs.",
        "version": "0.1",
        "x-build-id": "LCQaKqVluSUTMqy25"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~getyourguide-activities-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-getyourguide-activities-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-activities-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-getyourguide-activities-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-activities-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-getyourguide-activities-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": {
                    "startUrls": {
                        "title": "🔗 Search or destination URLs",
                        "type": "array",
                        "description": "GetYourGuide search or destination listing URLs. Activity detail URLs are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "queries": {
                        "title": "🔎 Search queries",
                        "type": "array",
                        "description": "Destinations or activity searches, for example Paris, Rome food tours, or London museums.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum activities",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after saving this many unique activity listings across all inputs.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum listing batches per source",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many rendered listing batches/scrolls to process for each source.",
                        "default": 3
                    },
                    "language": {
                        "title": "🌐 Browser language",
                        "type": "string",
                        "description": "BCP 47 browser locale used for rendered labels, for example en-US, de-DE, or fr-FR.",
                        "default": "en-US"
                    },
                    "currency": {
                        "title": "Currency",
                        "pattern": "^[A-Za-z]{3}$",
                        "type": "string",
                        "description": "Three-letter currency code requested from GetYourGuide, for example EUR, USD, or GBP.",
                        "default": "EUR"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential Apify Proxy is the proven default because GetYourGuide blocks plain HTTP and datacenter traffic. Custom proxies are also supported.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```