Viator Data API: Extract Structured JSON in 2026

TL;DR: To get structured Viator data via API, use a data API like AlterLab's Extract endpoint. By providing a target URL and a JSON schema, you receive validated, typed JSON containing specific travel details like price, rating, and location, bypassing the need for manual HTML parsing.

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

Why use Viator data?

Building a travel-focused data pipeline requires high-fidelity information that reflects real-time market conditions. Developers typically leverage a viator data api for three primary use cases:

1. Competitive Intelligence: Monitor price fluctuations across different regions to adjust your own travel offerings or dynamic pricing models.
2. AI Training and RAG: Feed high-quality, structured travel descriptions and metadata into LLMs to power specialized travel agents or recommendation engines.
3. Market Analytics: Aggregate large datasets of property names, ratings, and locations to identify emerging travel trends or underserved geographic markets.

What data can you extract?

When building a viator api structured data pipeline, you aren't just grabbing raw text; you are defining a data model. Because AlterLab uses LLM-powered extraction, you can target specific fields from publicly visible pages. Common fields include:

• property_name: The official title of the tour, activity, or accommodation.
• price_per_unit: The current listed cost (e.g., price per person or per night).
• rating: Numerical star ratings or review scores.
• location: Geographic identifiers, including city, country, or specific coordinates if available.
• availability: Textual or structured indicators of whether a service is currently bookable.
• description: Detailed text regarding the activity or property features.

The extraction approach: Why raw HTML parsing fails

In 2026, traditional web scraping via CSS selectors or XPath is a liability. Websites like Viator frequently update their DOM structures, meaning a single class name change can break your entire data pipeline.

The old way—writing custom regex or selector logic for every page—is fragile and high-maintenance. The modern way is to treat the web as a source of unstructured data that you transform into a structured API response. By using a data API, you move the complexity of DOM navigation, anti-bot bypass, and schema validation to the infrastructure layer. This allows you to focus on your application logic rather than debugging broken selectors.

Quick start with AlterLab Extract API

To begin, you need to set up your environment. If you haven't already, follow our Getting started guide.

The Extract API allows you to send a URL and a JSON schema. The engine handles the heavy lifting—including JavaScript rendering and proxy rotation—and returns only the data that matches your schema.

Python Implementation

The following example demonstrates how to use the Python client to perform viator json extraction.

import alterlab

client = alterlab.Client("YOUR_API_KEY")

# Define the structure of the data you want to retrieve
schema = {
  "type": "object",
  "properties": {
    "property_name": {
      "type": "string",
      "description": "The name of the tour or activity"
    },
    "price_per_unit": {
      "type": "string",
      "description": "The displayed price including currency"
    },
    "rating": {
      "type": "number",
      "description": "The numerical star rating"
    },
    "location": {
      "type": "string",
      "description": "The city or region"
    },
    "availability": {
      "type": "string",
      "description": "Availability status"
    }
  },
  "required": ["property_name", "price_per_unit"]
}

# Execute the extraction
result = client.extract(
    url="https://www.viator.com/search/example-tour-slug",
    schema=schema,
)

print(result.data)

Expected JSON Output:

{
  "property_name": "Sunset Sailing Cruise in Santorini",
  "price_per_unit": "$85.00",
  "rating": 4.8,
  "location": "Santorini, Greece",
  "availability": "Available"
}

cURL Implementation

For users preferring a language-agnostic approach, you can interact with the Extract API docs via standard HTTP requests.

curl -X POST https://api.alterlab.io/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.viator.com/search/example-tour-slug",
    "schema": {
      "type": "object",
      "properties": {
        "property_name": {"type": "string"},
        "price_per_unit": {"type": "string"},
        "rating": {"type": "number"}
      }
    }
  }'

Define your schema

The power of the viator data api lies in the schema. You aren't just asking for "the price"; you are defining that the price must be a string and that the property_name is a required field.

AlterLab uses these schemas to validate the output. If the LLM fails to find a required field, the request can be flagged, ensuring your downstream database doesn't ingest malformed or incomplete records. This is critical for maintaining data integrity in production pipelines.

Handle pagination and scale

When performing viator data extraction python at scale—for example, crawling hundreds of search result pages—you cannot rely on synchronous, one-off requests. You need a strategy for batching and concurrency.

For high-volume jobs, use our asynchronous patterns to prevent blocking your main execution thread.

import alterlab
import asyncio

client = alterlab.Client("YOUR_API_KEY")

urls = [
    "https://viator.com/tour-1",
    "https://viator.com/tour-2",
    "https://viator.com/tour-3"
]

schema = {"type": "object", "properties": {"property_name": {"type": "string"}}}

async def run_batch():
    # Create a list of extraction tasks
    tasks = [client.extract_async(url=u, schema=schema) for u in urls]
    # Execute concurrently
    results = await asyncio.gather(*tasks)
    for r in results:
        print(r.data)

asyncio.run(run_batch())

Managing Costs and Limits

As you scale, keep an eye on your AlterLab pricing. Because extraction is compute-intensive, costs are calculated based on the complexity of the page and the schema.

• Estimating Costs: Before running a large batch, use the POST /v1/extract/estimate endpoint to preview the cost of a specific request.
• Rate Limiting: To maintain high throughput without triggering site-level protections, we recommend using our managed proxy rotation and auto-escalation features.
• Scaling Tiers: For sites requiring heavy JavaScript execution, you can specify min_tier=3 in your request to ensure the browser environment is fully initialized.

Key takeaways

• Avoid fragile selectors: Use schema-based extraction to future-proof your travel data pipeline.
• Structured by design: Define your JSON schema upfront to receive typed, validated data ready for your database.
• Scale efficiently: Use asynchronous patterns and the cost estimation endpoint to manage large-scale viator data extraction projects.
• Focus on value: By delegating the extraction mechanics to a data API, you can spend more time on the analytics and AI applications that drive your business.

Hit reply if you have questions.

AlterLab // Web Data, Simplified.