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

Scrapes reviews from any GetYourGuide activity — rating, author, country, ISO date, text, traveler type, original language, verified-booking flag and review photos. Talks to GetYourGuide's own API, so no browser and no proxy are required.

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

## Pricing

from $2.50 / 1,000 reviews

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## GetYourGuide Reviews Scraper — Export Tour & Activity Reviews to JSON, CSV & Excel

**Scrape every public review from any GetYourGuide activity in seconds — no account, no API key, no coding.** Paste an activity URL, press Start, and download clean, structured review data.

- ⚡ **Fast** — a typical activity (~100 reviews) finishes in under 10 seconds
- 🎯 **Complete** — merges multiple passes to beat GetYourGuide's A/B-split review lists, so you don't silently lose reviews
- 🌍 **18 fields per review** — rating, text, reviewer country, traveler type, original language, verified-booking flag and photos
- 🔓 **No login, no API key** — and no browser, so runs stay cheap
- 💾 **Export anywhere** — JSON, CSV, Excel, XML, or straight into your app via the Apify API

***

### 📌 What This Actor Does

This Apify Actor is a **GetYourGuide reviews scraper**. Give it a GetYourGuide activity — as a full URL or just the numeric activity ID — and it collects that activity's public traveler reviews as structured data.

For every review you get the star rating, the full text, the reviewer's display name and country (name *and* ISO country code), a machine-readable ISO date, the traveler type (couple, family, friends, solo), whether the review came from a verified booking, which language it was originally written in, whether GetYourGuide translated it, and any photos the traveler uploaded — with every CDN image size.

For every activity you also get the average rating, a full star-by-star breakdown, and counters that tell you how complete the run was.

No programming is required. If you can copy a link, you can run this Actor.

#### Who it's for

| You are | You use it to |
|---|---|
| **Tour or activity operator** | See exactly what travelers say about your experiences — and your competitors' |
| **OTA / travel marketplace** | Benchmark suppliers, monitor experience quality, spot declining partners |
| **Market researcher / analyst** | Measure sentiment by destination, category, or season |
| **Data scientist / ML engineer** | Build multilingual, labelled review datasets with real rating signals |
| **Marketing / content team** | Find quotable praise and traveler-submitted photos for campaigns |
| **Destination marketing organisation** | Understand visitor experience across a city or region |

***

### ✨ Key Features

- **Two ways to enter an activity** — paste the full GetYourGuide URL, or just the numeric activity ID. Both work; mix them freely.
- **Bulk scraping** — queue as many activities as you like in a single run.
- **Completeness passes** — GetYourGuide serves different visitors different subsets of the same review list. This Actor runs several passes with fresh visitor identities and merges the results, then reports what each pass saw so you can *verify* completeness instead of hoping.
- **Real dates, not display strings** — every review carries an ISO 8601 date (`2026-09-07`) plus the full timestamp, so sorting and filtering just work.
- **Translation-aware** — each review records the language it was served in, the language the traveler actually wrote in, and whether GetYourGuide machine-translated it. Useful when you need authentic original-language text.
- **Reviewer context** — country name, ISO country code, and traveler type (couple, family with young kids, family with older kids, friends, solo).
- **Verified bookings flagged** — know which reviews came from a confirmed booking.
- **Review photos included** — every traveler photo with all eight CDN sizes (thumb through desktop), so you can pick the resolution you need without rewriting URLs.
- **Computed stats** — average rating and a star-by-star breakdown, calculated from the data you actually received.
- **Date filter and caps** — keep only reviews newer than a date, or cap the total.
- **Consistent schema** — every review has the same 18 fields in the same order, so CSV and Excel exports line up and nothing shifts between runs.

***

### 🧠 Why This Actor Is Different

Most GetYourGuide scraping attempts quietly return a fraction of the reviews. This one was built around three failure modes that were measured, not guessed:

**1. It doesn't trust GetYourGuide's "load more" cursor.**
The site's own pagination cursor is missing 7 times out of 12 *even when more reviews exist*. Following it truncated a 110-review activity to 20. This Actor paginates by offset itself and only stops when two consecutive pages return nothing new.

**2. It detects failures that arrive as successes.**
GetYourGuide's API can return an error block with **HTTP status 200**. A naive scraper reads that as "end of list" and stops early. This Actor recognises the marker and retries — and uses the one page size (20) measured to produce a 0% error rate. At page size 50, half the requests fail this way.

**3. It defeats the A/B split on the review list.**
GetYourGuide buckets its review list by visitor identity, and the bucket is sticky: one identity returned 98 reviews where another returned 110 for the same activity. Scrape once and you may never know you're missing 12 reviews. This Actor runs multiple passes with fresh identities, merges them, and publishes each pass's count in the output.

**Plus:** no headless browser anywhere in the pipeline. That makes runs fast and cheap, and removes the flakiness that browser-based scrapers carry.

***

### ⚙️ Input Configuration

| Field | Type | Default | What it does |
|---|---|---|---|
| `startUrls` | array | *required* | GetYourGuide activity URLs, or bare numeric activity IDs |
| `maxReviews` | integer | `0` | Cap on total reviews across all URLs. `0` = no limit |
| `targetDate` | string | — | Keep only reviews newer than this ISO date (e.g. `2025-01-01`) |
| `language` | string | `en-US` | Participant language sent to GetYourGuide |
| `currency` | string | `EUR` | Required by the API; does not affect review content |
| `visitorIdAttempts` | integer | `2` | How many completeness passes to run (1–5) |
| `proxyConfiguration` | object | Apify Proxy | Optional. The API answers direct requests too |

#### Choosing activities

Any of these work:

```
https://www.getyourguide.com/toulouse-l288/toulouse-cite-de-l-espace-e-codes-t672631/
https://www.getyourguide.com/paris-l16/eiffel-tower-summit-t12345/?ref=search
672631
```

The activity ID is the number after `-t` in the URL. Query strings and tracking parameters are stripped automatically.

#### Language options

`en-US` (default), `fr-FR`, `de-DE`, `es-ES`, `it-IT`, `nl-NL`, `pt-PT`.

This controls which language GetYourGuide *serves* reviews in — some come back machine-translated, others in their original language. It does **not** change how many reviews you get. Every review tells you which happened via its `language`, `originalLanguage` and `isTranslated` fields.

#### Currency options

`EUR` (default), `USD`, `GBP`, `CHF`, `MAD`. The API rejects requests without a currency, but it has no effect on review content — leave it alone unless you have a reason.

#### 💡 Tips for best results

- **Leave `visitorIdAttempts` at 2.** Two passes covered the full review set in every test. Raise it to 3–5 only when `bucketSizes` in your output shows the passes disagreeing a lot.
- **Turn the proxy off for short runs.** GetYourGuide's API answers direct requests and showed no rate limiting across sustained runs, so on a handful of activities a proxy is cost without benefit — and it will *not* fix a 403 (see the FAQ). Keep it on when you queue a lot of activities in one go.
- **`targetDate` filters, it doesn't speed things up.** GetYourGuide returns reviews in a non-deterministic order, so the Actor completes the walk and then filters. Same for `maxReviews`.
- **Queue many activities in one run** rather than one run per activity — it's fewer runs to manage and the same total work.

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.getyourguide.com/toulouse-l288/toulouse-cite-de-l-espace-e-codes-t672631/" },
    { "url": "https://www.getyourguide.com/paris-l16/louvre-museum-t54321/" }
  ],
  "maxReviews": 0,
  "targetDate": "2025-01-01",
  "language": "en-US",
  "currency": "EUR",
  "visitorIdAttempts": 2
}
```

***

### 📤 Output Format

The Actor pushes **one dataset record per activity**, containing the activity's stats and a `reviews` array.

#### Sample output

```json
{
  "source": "getyourguide",
  "activityId": 672631,
  "activityUrl": "https://www.getyourguide.com/toulouse-l288/toulouse-cite-de-l-espace-e-codes-t672631/",
  "language": "en-US",
  "reviewsCollected": 112,
  "reviewsFoundBeforeFilters": 112,
  "bucketSizes": [112, 99],
  "averageRating": 4.3,
  "ratingBreakdown": { "1": 6, "2": 5, "3": 11, "4": 17, "5": 73 },
  "stoppedBy": null,
  "requestsMade": 16,
  "scrapedAt": "2026-09-21T09:41:22.786Z",
  "reviews": [
    {
      "source": "getyourguide",
      "reviewId": 127492001,
      "activityId": 672631,
      "rating": 4,
      "author": "GetYourGuide traveler",
      "authorCountry": "Italy",
      "countryCode": "IT",
      "date": "2026-09-07",
      "dateRaw": "2026-09-07T11:15:09+02:00",
      "dateLabel": "September 7, 2026 - Verified booking",
      "text": "Bel parco a tema spaziale. Se non si è stati già alla NASA negli USA sicuramente vale la pena visitarlo.",
      "textLength": 164,
      "language": "it",
      "originalLanguage": "it",
      "isTranslated": false,
      "travelerType": "family_young",
      "verifiedBooking": true,
      "images": [
        {
          "mediaId": 8234469,
          "type": "reviewImage",
          "url": "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/145.jpg",
          "sizes": {
            "small":      "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/97.jpg",
            "medium":     "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/98.jpg",
            "large":      "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/99.jpg",
            "gallery":    "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/107.jpg",
            "desktop":    "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/145.jpg",
            "mobile":     "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/146.jpg",
            "thumb":      "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/53.jpg",
            "largeThumb": "https://cdn.getyourguide.com/img/review/857046…d7a9.jpg/161.jpg"
          }
        }
      ]
    }
  ]
}
```

#### Activity fields

| Field | Type | Description |
|---|---|---|
| `source` | string | Always `"getyourguide"` — handy when merging data from several scrapers |
| `activityId` | number | GetYourGuide's numeric activity ID |
| `activityUrl` | string | The URL you supplied, with tracking parameters stripped. `null` if you passed a bare ID |
| `language` | string | The participant language used for this run |
| `reviewsCollected` | number | How many reviews are in this record, after your filters |
| `reviewsFoundBeforeFilters` | number | How many the walk found before `targetDate` / `maxReviews` were applied |
| `bucketSizes` | array | What each completeness pass saw, e.g. `[112, 99]`. Your completeness signal |
| `averageRating` | number | Mean rating of the collected reviews, 2 decimals |
| `ratingBreakdown` | object | Count per star, e.g. `{"5": 73, "4": 17}` |
| `stoppedBy` | string | `"targetDate"`, `"maxReviews"`, or `null` if nothing was cut |
| `requestsMade` | number | API requests used — useful for cost tracking |
| `scrapedAt` | string | ISO timestamp of the run |
| `reviews` | array | The reviews, newest first |

#### Review fields

| Field | Type | Description |
|---|---|---|
| `reviewId` | number | Stable GetYourGuide review ID — use it to deduplicate across runs |
| `rating` | number | 1–5 stars |
| `author` | string | Display name. Anonymous reviewers appear as `"GetYourGuide traveler"` |
| `authorCountry` | string | Country name as displayed, e.g. `"Italy"` |
| `countryCode` | string | ISO 3166-1 alpha-2 code, e.g. `"IT"` |
| `date` | string | `YYYY-MM-DD` — sortable and filterable |
| `dateRaw` | string | Full ISO timestamp with timezone offset |
| `dateLabel` | string | The localised label as shown on the site |
| `text` | string | The review body. `null` when the traveler left a rating only |
| `textLength` | number | Character count, as reported by GetYourGuide |
| `language` | string | Language the text was served in |
| `originalLanguage` | string | Language the traveler actually wrote in |
| `isTranslated` | boolean | `true` when GetYourGuide machine-translated the text |
| `travelerType` | string | `couple`, `family_young`, `family_old`, `friends`, or `solo` |
| `verifiedBooking` | boolean | `true` when the review came from a confirmed booking |
| `images` | array | Traveler photos: `mediaId`, `type`, best `url`, and all `sizes` |

> **Note:** roughly half of GetYourGuide reviews are ratings with no written text. Those records have `text: null`, `textLength: 0` and an empty `language` — that's normal, not a scraping failure. The rating, date, country and traveler type are still there.

***

### ▶️ How to Use

#### Step 1 — Open the Actor

Click **Try for free** on the Apify Store page. You'll land in the Apify Console.

#### Step 2 — Add your activities

Paste one or more GetYourGuide activity URLs into **Activity URLs**. A bare numeric ID works too.

#### Step 3 — Set your filters (optional)

Set **Only reviews newer than** for a date cutoff, or **Max reviews** to cap the total. Skip both to get everything.

#### Step 4 — Run it

Press **Start**. A typical activity finishes in under 10 seconds.

#### Step 5 — Download

Open the **Dataset** tab and export as JSON, CSV, Excel, XML or HTML — or pull it straight from the Apify API.

#### Common workflows

**Track new reviews daily.** Schedule the Actor to run each morning with `targetDate` set to yesterday. Deduplicate on `reviewId`.

**Benchmark competitors.** Put your activity and 5–10 competing activities in one run, then compare `averageRating` and `ratingBreakdown` across the dataset records.

**Build a multilingual sentiment dataset.** Run with `maxReviews: 0`, then filter to `isTranslated: false` so you only train on text travelers actually wrote.

**Pull traveler photos.** Filter to reviews where `images` is non-empty and grab the `url` of each — every CDN size is included.

***

### 📈 Use Cases

#### 1. Competitive analysis for tour operators

Scrape every competing activity in your city and compare ratings, complaint themes, and traveler types. Find the gap your experience can fill — and the recurring complaint that's costing a competitor bookings.

#### 2. Review monitoring and quality alerts

Run daily with a date cutoff and pipe new reviews into Slack or a spreadsheet. A run of 2-star reviews mentioning the same guide shows up in hours, not at the end of the season.

#### 3. Sentiment analysis and AI training data

Reviews arrive with a numeric rating, the original language, and a translation flag — a labelled, multilingual dataset that needs almost no cleaning before it goes into a model.

#### 4. Travel market research

Aggregate reviews across a destination to measure seasonality, which traveler types book which experiences, and how satisfaction differs by nationality using `countryCode`.

#### 5. Marketing content and social proof

Filter to 5-star reviews with photos and `verifiedBooking: true` to source authentic testimonials and user-generated images for landing pages and ads.

#### 6. Due diligence on suppliers

Marketplaces and investors can measure a supplier's real review volume, trend, and rating distribution — including how many reviews are text-free ratings.

***

### 🛠️ Advanced Tips

#### Performance and throughput

Each completeness pass costs about 8 API requests per 100 reviews. A full 2-pass run on a ~100-review activity takes roughly 6–7 seconds end to end. Activities are processed sequentially, so 10 activities ≈ 10× that.

#### Tuning completeness vs. speed

`visitorIdAttempts` is the only real throughput lever:

- **1 pass** — fastest, half the requests, but may under-collect
- **2 passes** (default) — covered the full set in every test
- **3–5 passes** — extra redundancy for high-value activities

Check `bucketSizes` in your output. If the numbers are identical, the extra passes found nothing new and you can drop to 1 for that activity. If they differ, keep them.

#### Keeping costs down

- Turn the proxy off on small runs — the API answers direct requests, so it's cost with no benefit there.
- Use `visitorIdAttempts: 1` for quick exploratory runs, then re-run important activities with 2.
- Use `targetDate` on scheduled runs so you store only what's new (it won't shorten the run, but it keeps your dataset clean).

#### Proxy usage

Apify Proxy is prefilled, but optional — GetYourGuide's API answers direct requests and showed no rate limiting in testing. When it's on, the Actor takes a fresh proxy session for each retry attempt and logs the session ID so you can trace a failure. **A proxy will not fix a 403** — see the FAQ.

#### Scaling to many activities

Queue activities in a single run rather than launching many runs. For very large jobs, split them across several scheduled runs so each run's dataset stays easy to export.

#### Automation

Use Apify's scheduler for recurring runs, and webhooks to push finished datasets into your warehouse, Google Sheets, or a Slack channel.

***

### ❓ FAQ & Troubleshooting

**Do I need a GetYourGuide account or API key?**
No. The Actor uses publicly available review data. No login, no key, no cookies.

**Do I need a proxy?**
No. GetYourGuide's review API answers direct requests and showed no rate limiting across sustained testing. Apify Proxy is switched on by default because it keeps a long run from hammering one IP; clear it and the Actor runs direct.

**Why did two runs of the same activity return slightly different review counts?**
GetYourGuide splits its review list by visitor identity — one identity sees 98 reviews, another sees 110 for the same activity. That's the site's behaviour, not a bug. The Actor works around it by running multiple passes and merging them; `bucketSizes` shows you exactly what each pass saw. Raise `visitorIdAttempts` to 3 or more for maximum coverage.

**Why do many reviews have no text?**
Roughly half of GetYourGuide reviews are star ratings with no written review. Those come back with `text: null`. The rating, date, country and traveler type are still there.

**Why doesn't `maxReviews` make my run faster?**
GetYourGuide returns reviews in a non-deterministic order and publishes no total count, so the Actor completes the walk and then keeps the newest N. Stopping early would drop newer reviews that happen to sort later. The same applies to `targetDate`.

**Can I scrape all activities from a supplier, a city, or a search page?**
Not yet — this Actor takes activity URLs or IDs. Collect the URLs you care about and queue them in one run.

**Can I get the activity's name, price, or availability?**
No. This Actor covers reviews. GetYourGuide's review API returns only the activity ID alongside the reviews, and the Actor deliberately never loads the product page.

**I got a 403 error. Should I turn on a proxy?**
No — a 403 here means GetYourGuide changed the shape it expects from a request, not that your IP is blocked. Rotating IPs won't help. Report it (see Support) and it'll be fixed in the Actor.

**I got a 404 / "activity does not exist".**
The activity ID wasn't found. Check the number after `-t` in your URL — GetYourGuide retires activities, and retired ones stop returning reviews.

**How far back do reviews go?**
As far back as GetYourGuide publishes for that activity. Reviews come newest first.

**Can I run this on a schedule?**
Yes. Use Apify's built-in scheduler, and set `targetDate` to your last run date to keep each dataset focused on new reviews.

**Is the data legal to use?**
The Actor collects publicly visible review data. How you store and use it — especially personal data such as reviewer names — is your responsibility under GDPR and GetYourGuide's terms. When in doubt, aggregate, and drop the `author` field.

***

### 📞 Support

Found a bug, need a field that isn't there, or want to scrape something this Actor doesn't cover yet?

- **Issues:** use the **Issues** tab on this Actor's Apify Store page — the fastest way to get a fix, and other users can see it
- **Email:** <me@ahmedhrid.com>

Feature requests are welcome. If you need supplier-level or city-level scraping, bulk activity discovery, or a custom output shape, get in touch.

***

### 🔗 Related keywords

GetYourGuide scraper · GetYourGuide reviews scraper · scrape GetYourGuide · GetYourGuide API · travel review scraping · tour and activity reviews · web scraping · Apify Actor · travel data extraction · tourism market research · review monitoring · export reviews to CSV · export reviews to Excel · multilingual review dataset · traveler sentiment analysis

# Actor input Schema

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

GetYourGuide activity URLs (the activity id is read from the '-t<digits>' part of the slug). A bare numeric activity id also works.

## `maxReviews` (type: `integer`):

Stop after this many reviews across all URLs. 0 means no limit. Note: GetYourGuide returns reviews in a non-deterministic order, so the actor always completes the walk and then keeps the newest N.

## `targetDate` (type: `string`):

Drop reviews older than this date (ISO 8601, e.g. 2025-01-01). Because GetYourGuide's review order is non-deterministic, this filters after the full walk rather than stopping early — so it does not make a run faster.

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

Participant language sent to the API. GetYourGuide serves some reviews machine-translated into this language and others in their original language — each review records which happened via its 'language', 'originalLanguage' and 'isTranslated' fields. It does not change how many reviews you get.

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

Sent as the required 'accept-currency' header. Does not affect review content, but the API rejects the request without it.

## `visitorIdAttempts` (type: `integer`):

GetYourGuide A/B-buckets its review list by visitor id: one bucket can return fewer reviews than another (e.g. 98 vs 110 for the same activity), and the bucket is sticky per id. The actor runs this many passes with fresh visitor ids and merges the results. 2 covered the full set in every test; 1 is faster but may under-collect; 3 adds redundancy.

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

The API answers direct requests too, but a proxy keeps long runs off a single IP. Note a proxy will NOT help with a 403 — that means the required header set changed.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.getyourguide.com/toulouse-l288/toulouse-cite-de-l-espace-e-codes-t672631/"
    }
  ],
  "maxReviews": 0,
  "language": "en-US",
  "currency": "EUR",
  "visitorIdAttempts": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with one record per GetYourGuide activity: the activity's id, URL, collected/found counts, per-pass bucket sizes, average rating and rating breakdown, plus the array of review objects (newest first).

# 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/toulouse-l288/toulouse-cite-de-l-espace-e-codes-t672631/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/getyourguide-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.getyourguide.com/toulouse-l288/toulouse-cite-de-l-espace-e-codes-t672631/" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/getyourguide-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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/toulouse-l288/toulouse-cite-de-l-espace-e-codes-t672631/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call reviewly/getyourguide-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reviewly/getyourguide-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/w7DuFFwqh0MgAwz6M/builds/7F31VmUtsKlz2Xpjb/openapi.json