GetYourGuide Data API: Extract Structured JSON in 2026

This guide covers extracting publicly accessible data. Always review a site's robots.txt and Terms of Service before scraping.

TL;DR

Use AlterLab's Extract API to turn any GetYourGuide listing page into structured JSON. Define a JSON schema for the fields you need (e.g., property_name, price_per_night, rating), POST the URL and schema, and receive typed data ready for downstream pipelines. No HTML parsing, no fragile selectors.

Why use GetYourGuide data?

Travel platforms like GetYourGuide aggregate millions of tours, activities, and attractions. Structured access to this data enables:

• Training ML models for price prediction or recommendation systems.
• Market analytics to monitor competitor offerings and identify trends.
• Content enrichment for travel apps, aggregators, or AI agents that need up‑to‑date listings.

These use cases rely on reliable, machine‑readable output — exactly what a data API delivers.

What data can you extract?

GetYourGuide pages expose the following publicly available fields:

• property_name – title of the tour or activity.
• price_per_night – displayed cost (often per person or per booking).
• rating – aggregate score from user reviews.
• location – city, neighborhood, or venue.
• availability – dates or time slots shown on the page.

Because the data is presented in HTML, extracting it with regex or CSS selectors breaks whenever the site updates its layout. A schema‑based API sidesteps that fragility.

The extraction approach

Raw HTTP requests followed by HTML parsing require constant maintenance: selectors change, anti‑bot measures trigger CAPTCHAs, and JavaScript‑rendered content needs a headless browser. AlterLab handles all of that — rotating proxies, automatic retry, and JavaScript rendering — then applies a language model to map the page to your JSON schema. The result is a data API: you ask for structured data, you get structured data, with zero parsing on your side.

Quick start with AlterLab Extract API

First, install the Python client (or use cURL directly). See the Getting started guide for installation details.

Python example

import alterlab

client = alterlab.Client("YOUR_API_KEY")

schema = {
  "type": "object",
  "properties": {
    "property_name": {
      "type": "string",
      "description": "The property name field"
    },
    "price_per_night": {
      "type": "string",
      "description": "The price per night field"
    },
    "rating": {
      "type": "string",
      "description": "The rating field"
    },
    "location": {
      "type": "string",
      "description": "The location field"
    },
    "availability": {
      "type": "string",
      "description": "The availability field"
    }
  }
}

result = client.extract(
    url="https://getyourguide.com/example-page",
    schema=schema,
)
print(result.data)

Lines 5‑12 show the schema definition and the extract call.

cURL equivalent

curl -X POST https://api.alterlab.io/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://getyourguide.com/example-page",
    "schema": {"properties": {"property_name": {"type": "string"}, "price_per_night": {"type": "string"}, "rating": {"type": "string"}}}
  }'

The response is a JSON object whose keys match your schema, with values already typed as strings (you can specify numbers, booleans, etc., in the schema).

Batch/async usage (Python)

For high‑volume jobs, fire off multiple extract requests concurrently and handle the results as they arrive.

import asyncio
import alterlab

async def extract_one(client, url, schema):
    return await client.extract_async(url=url, schema=schema)

async def main():
    client = alterlab.Client("YOUR_API_KEY")
    schema = {
        "type": "object",
        "properties": {
            "property_name": {"type": "string"},
            "price_per_night": {"type": "string"},
            "rating": {"type": "string"},
        },
    }
    urls = [
        "https://getyourguide.com/paris-louvre-ticket",
        "https://getyourguide.com/rome-colosseum-tour",
        "https://getyourguide.com/tokyo-sushi-making-class",
    ]
    coroutines = [extract_one(client, u, schema) for u in urls]
    results = await asyncio.gather(*coroutines)
    for r in results:
        print(r.data)

if __name__ == "__main__":
    asyncio.run(main())

This pattern scales to thousands of URLs while respecting rate limits (see the pricing page for cost estimates).

Define your schema

The schema parameter drives the entire extraction. AlterLab validates the model output against it, guaranteeing that every field exists and matches the declared type. Example schema for a travel listing:

{
  "type": "object",
  "properties": {
    "property_name": {"type": "string"},
    "price_per_night": {"type": "number"},
    "rating": {"type": "number", "minimum": 0, "maximum": 5},
    "location": {"type": "string"},
    "availability": {"type": "array", "items": {"type": "string"}}
  },
  "required": ["property_name", "price_per_night", "rating"]
}

If the model cannot confidently extract a field, it returns null for optional types or omits the field if not required. This eliminates guesswork and makes downstream processing deterministic.

Handle pagination and scale

GetYourGuide often paginates results across multiple pages (e.g., /activities?page=2). To collect large datasets:

1. Discover page URLs via the site’s listing endpoints or by following “next” links.
2. Batch requests in groups of 50‑100 to stay within comfortable concurrency limits.
3. Monitor cost — each extraction costs between $0.001 and $0.50. For bulk jobs, consult the pricing page to estimate spend.
4. Store results incrementally (e.g., append to a JSON Lines file) to avoid losing progress on failure.

AlterLab’s backend automatically retries failed attempts and applies exponential backoff, so your pipeline remains resilient.

Key takeaways

• Use a data API, not a scraper, to get typed JSON from GetYourGuide with zero parsing.
• Define a clear JSON schema; AlterLab validates output and reduces maintenance.
• Start with a single URL, then scale to batches using async