# Tiqets Attraction & Ticket Price Finder (`nimbryxo-studio/tiqets-attraction-and-ticket-price-finder-by-city`) Actor

Scrape Tiqets attractions, tours and tickets by keyword, city, category, URL or ID: prices, ratings, discounts, images, coordinates, inclusions, opening hours and optional availability. No API key or login.

- **URL**: https://apify.com/nimbryxo-studio/tiqets-attraction-and-ticket-price-finder-by-city.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Travel, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Tiqets Attraction & Ticket Price Finder

Tiqets lists museum, tour and attraction tickets across major cities worldwide. This actor searches that catalog by keyword, browses every venue in a city or category, or fetches specific venue/product URLs and IDs. It returns ratings, review counts, prices in 21 currencies, discount percentages, images, coordinates, categories, inclusions, opening hours and optional availability dates/timeslots. No account, user cookies or API key required.

### What this actor does

- **Five modes:** `search`, `browseByCity`, `browseByCategory`, `byUrl`, `byId`
- **Paged collection** — gathers up to `maxItems` across all result pages
- **81 destination cities** and **66 category tags**, verified against Tiqets' public catalog
- **17 site locales** and **21 supported currencies**
- **Venue, product and package records** with nested venue/city/country metadata
- **Optional availability** — dates and timeslots for products and packages
- **Server-side filters where verified** — `cityIds` and `experienceTagIds` in search; `sortType=popularity|rating` in city/category browse
- **Client-side filters** — min/max rating, min/max price, top-rated only and discount-only in browse modes
- **Empty fields are omitted at every depth** — no `null`, `""`, `[]` or `{}` in output

### Modes

| Mode | What it does |
|---|---|
| `search` | Keyword search; supports one query or several queries |
| `browseByCity` | All venues in a city; supports `city`, `cities[]` and `cityIds[]` |
| `browseByCategory` | Products in a city category; supports `category` and `experienceTagIds[]` |
| `byUrl` | Venue, product, city or category URLs; the URL locale is preserved |
| `byId` | Venue IDs and product/package IDs, resolved to their current Tiqets page |

City and category browse also accept multi-city inputs. Search accepts multiple queries; results are de-duplicated by product/venue ID.

### Output per venue, product or package

One dataset record per venue, ticket product or package. Fields that exist for the record are emitted; empty fields are omitted.

- `recordType` — `venue`, `product` or `package`
- `venueId` / `productId`, `name` / `productTitle`
- `description`, `shortDescription`, `summary`
- `images[]`, `imageUrl`
- `rating`, `reviewCount`, `reviews[]` (up to 3 samples with author, date, rating and text)
- `price`, `priceCurrency`, `priceEur`, `displayPrice`, `discountPercentage`
- `venue` `{id,name,url}`, `city`, `cityId`, `cityInfo` `{id,name,slug}`, `country` `{id,name}`, `countryId`
- `categories[]`, `tags[]`, `category`
- `duration`, `keyDetails`, `whatsIncluded`, `whatsExcluded`, `openingHours`
- `checkoutDisabled`, `offerCount`, `topPrice`, `topPriceEur`
- `latitude`, `longitude`
- `availabilityDates[]`, `availabilityTimeslots` `{date: [times]}` (optional; omitted when none)
- `productUrl`, `sourceUrl`, `slug`, `startDate`, `language`, `recordType`, `scrapedAt`

Detail modes (`byUrl`, `byId`) parse the page's JSON-LD and dataLayer. A product page does not contain coordinates, so the actor fetches its venue page once (cached per run) to add coordinates, country and extra images.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` / `browseByCity` / `browseByCategory` / `byUrl` / `byId` |
| `searchQuery` | string | `eiffel tower` | Free-text query (mode=search) |
| `searchQueries` | array | – | Multiple queries (mode=search); combined and de-duplicated |
| `city` | select | – | One destination city (browse modes) |
| `cities` | array | – | Multiple city slugs (browse modes) |
| `cityIds` | array | – | Numeric city IDs; server-side filter in search, browse targets in browse modes |
| `category` | select | – | One of 66 verified category tags (mode=browseByCategory) |
| `experienceTagIds` | array | – | Numeric category tag IDs; server-side filter in search, category paths in browse |
| `startUrls` | array | – | Venue/product/city/category URLs (mode=byUrl); locale preserved |
| `venueIds` | array | – | Numeric venue IDs (mode=byId) |
| `productIds` | array | – | Numeric product IDs (mode=byId) |
| `language` | select | `en` | 17 locales: `ca,cs,da,de,el,en,es,fr,it,ja,ko,nl,pl,pt,ru,sv,zh` |
| `currency` | select | `EUR` | 21 supported currencies: `EUR,USD,GBP,CHF,CAD,AUD,AED,BRL,CZK,DKK,HKD,HUF,INR,JPY,MXN,NOK,NZD,PLN,SEK,SGD,THB` |
| `minRating` | integer | – | Client-side lower rating bound (1–5); missing ratings pass |
| `maxRating` | integer | – | Client-side upper rating bound (1–5); missing ratings pass |
| `minPrice` | integer | – | Client-side lower price bound in the selected currency; missing prices pass |
| `maxPrice` | integer | – | Client-side upper price bound in the selected currency; missing prices pass |
| `topRatedOnly` | boolean | `false` | Only ratings 4.5+ |
| `hasDiscount` | boolean | `false` | Keeps only records with `discountPercentage > 0` |
| `sortType` | select | `popularity` | `popularity` or `rating` (city/category browse only; search ignores sort) |
| `includeExtraVenues` | boolean | `true` | SSR fallback only: also emit venue links outside the main listing |
| `includeAvailability` | boolean | `false` | Fetch dates and timeslots for product/package records |
| `availabilityDays` | integer | `14` | Days ahead to request (1–30) |
| `maxItems` | integer | `50` | Hard cap on emitted records (1–10,000) |
| `proxyConfiguration` | proxy | – | Optional user-supplied proxy; direct requests are tried first and free Apify Proxy is used only if they are blocked |

#### Example: search

```json
{
  "mode": "search",
  "searchQuery": "louvre",
  "language": "en",
  "currency": "EUR",
  "maxItems": 50
}
```

#### Example: browse all venues in Paris

```json
{
  "mode": "browseByCity",
  "city": "paris",
  "maxItems": 200
}
```

#### Example: museums in Paris (96 products)

```json
{
  "mode": "browseByCategory",
  "city": "paris",
  "category": "museums",
  "maxItems": 100
}
```

#### Example: fetch specific pages (locale preserved)

```json
{
  "mode": "byUrl",
  "startUrls": [
    { "url": "https://www.tiqets.com/fr/billets-tour-eiffel-l144586/" },
    { "url": "https://www.tiqets.com/en/things-to-do-in-paris-c66746/tickets-for-musee-d-orsay-dedicated-entrance-p973980/" },
    { "url": "https://www.tiqets.com/en/things-to-do-in-paris-c66746/museums-t2968/" }
  ]
}
```

#### Example: venue and product IDs

```json
{
  "mode": "byId",
  "venueIds": ["144586"],
  "productIds": ["973980"],
  "includeAvailability": true,
  "availabilityDays": 7
}
```

### Use cases

- **Travel product research** — compare attraction and museum ticket prices across cities
- **Itinerary planning** — enrich trip catalogues with live ticket, rating and opening-hours data
- **Price monitoring** — track discount percentages and availability for key attractions
- **Marketplace analytics** — analyse category coverage and venue counts by destination
- **Availability checks** — collect dates and timeslots for ticketed products and packages

### FAQ

**Do I need an API key or account?**
No. It requires no account or user cookies.

**Are prices in my selected currency?**
Yes for search, city and category results. Some detail pages are served in EUR by Tiqets; when availability is enabled, the selected-currency availability price is used for detail records. Price filters on detail modes compare the returned page price, which may be EUR.

**Why does a product record have coordinates when the product page has none?**
The actor fetches the product's venue page once per run and merges coordinates, country and extra images.

**How fresh is the data?**
Every run reads live public pages/endpoints, so values reflect Tiqets at run time.

**Is this actor affiliated with Tiqets?**
No. This is an independent third-party actor using Tiqets' public website.

**How many records can I get in one run?**
Up to 10,000 (`maxItems`). The actor paginates until the cap or the last page.

### Verified counts and limits

- **Paris city browse:** 134 venues; **Rome:** 110; **Paris museums:** 96 products (verified 2026-11).
- **Page size is 20.** The actor paginates automatically until the cap or last page.
- **`maxItems` up to 10,000.** Pagination stops at the cap or the last page. Filtering happens after fetch; if filters drop many rows, the actor continues through all pages.
- **Search sorting is not available.** Price sorting is not offered by the source.
- **City/category sort** supports popularity and rating.
- **Beijing has no current Tiqets city destination.** The old city ID resolves elsewhere, so Beijing is not offered.
- **Discount filtering is applied to emitted records.** This avoids unrelated global discount results.
- **Availability is optional and applies to products and packages.** City browse returns venues, which have no single product ID, so availability is omitted for those records. Timeslots are requested once per available date.
- **Product/package IDs resolve to their current page**, including IDs missing from a locale index.
- **Missing rating/price pass filters** by design; this keeps package cards and sparse listing rows that do not publish those fields.

### Data source and robots

Tiqets (tiqets.com) is an online ticketing platform for attractions, museums and tours. This actor reads Tiqets' public pages and endpoints. No account, user cookies or API key is required. The actor chooses a working connection automatically; no proxy setup is needed.

The actor uses public endpoints also used by Tiqets' own front end. It is not a strict robots-only crawler; use detail-only modes if that constraint is required.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

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

Free-text query, e.g. `eiffel tower`, `louvre`, `hop on hop off bus` (mode=search). Kept for backward compatibility; use `searchQueries` for multiple queries.

## `searchQueries` (type: `array`):

One or more free-text queries (mode=search). Every query is paginated to `maxItems`; duplicate products are removed.

## `city` (type: `string`):

Destination city (modes=browseByCity, browseByCategory). Kept for backward compatibility; use `cities` for multiple cities.

## `cities` (type: `array`):

Browse several cities in one run (modes=browseByCity, browseByCategory). City slugs from the `city` dropdown.

## `cityIds` (type: `array`):

Numeric Tiqets city IDs. In search mode this is a verified server-side filter (`cityIds`); in browse modes each ID is browsed directly.

## `category` (type: `string`):

Category browse slug (mode=browseByCategory). 66 verified category tags; a tag may return 0 products in a given city.

## `experienceTagIds` (type: `array`):

Numeric Tiqets category tag IDs. Server-side `experienceTagIds` filter in search mode; category paths in browseByCategory.

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

Venue (`...-l123/`), product (`...-p456/`), city (`...-c66746/`) or category (`.../museums-t2968/`) URLs. The input locale is preserved.

## `venueIds` (type: `array`):

Numeric Tiqets venue IDs, e.g. `144586`. Resolved through `/{locale}/tickets-l{id}/` redirects.

## `productIds` (type: `array`):

Numeric Tiqets product/package IDs, e.g. 973980. Resolved through the public product redirect route; the product sitemap is a fallback.

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

Site language. 17 real sitemap locales; ar/tr redirect to English and are not offered.

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

Price currency. Only currencies accepted by the public web_api are listed (unsupported ones return HTTP 400).

## `minRating` (type: `integer`):

Client-side: drop records rated below this (1-5). Records with no rating pass through.

## `maxRating` (type: `integer`):

Client-side: drop records rated above this (1-5). Records with no rating pass through.

## `minPrice` (type: `integer`):

Client-side: drop records with a price below this in the selected currency. Records with no price pass through.

## `maxPrice` (type: `integer`):

Client-side: drop records with a price above this in the selected currency. Records with no price pass through.

## `topRatedOnly` (type: `boolean`):

Client-side: only emit records rated 4.5 or higher.

## `hasDiscount` (type: `boolean`):

Client-side discount filter. The search API ignores the query when hasDiscount is sent, so the actor keeps the query and filters results locally.

## `sortType` (type: `string`):

Verified server-side sort for city/category browse. Search ignores sort parameters. Price sorting is not supported by the API.

## `includeExtraVenues` (type: `boolean`):

Only used by the SSR fallback: also emit venue links found outside the main listing. API results already include every venue.

## `includeAvailability` (type: `boolean`):

Fetch optional dates/timeslots for product and package records. Adds one dates request plus one timeslots request per available date; omitted when the API returns none.

## `availabilityDays` (type: `integer`):

How many days ahead to request when `includeAvailability` is on (1-30).

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

Hard cap on emitted records. Pagination continues until this cap or the last page. API page size is fixed at 20.

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

Optional user-supplied proxy. No account, user cookies or API key is required. Direct requests are tried first; free Apify Proxy is used only if they are blocked.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "eiffel tower",
  "searchQueries": [],
  "cities": [],
  "cityIds": [],
  "experienceTagIds": [],
  "startUrls": [],
  "venueIds": [],
  "productIds": [],
  "language": "en",
  "currency": "EUR",
  "topRatedOnly": false,
  "hasDiscount": false,
  "sortType": "popularity",
  "includeExtraVenues": true,
  "includeAvailability": false,
  "availabilityDays": 14,
  "maxItems": 3
}
```

# Actor output Schema

## `attractions` (type: `string`):

Dataset containing all scraped Tiqets venues, products and packages.

# 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 = {
    "mode": "search",
    "searchQuery": "eiffel tower",
    "searchQueries": [],
    "cities": [],
    "cityIds": [],
    "experienceTagIds": [],
    "startUrls": [],
    "venueIds": [],
    "productIds": [],
    "language": "en",
    "currency": "EUR",
    "topRatedOnly": false,
    "hasDiscount": false,
    "sortType": "popularity",
    "includeExtraVenues": true,
    "includeAvailability": false,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/tiqets-attraction-and-ticket-price-finder-by-city").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 = {
    "mode": "search",
    "searchQuery": "eiffel tower",
    "searchQueries": [],
    "cities": [],
    "cityIds": [],
    "experienceTagIds": [],
    "startUrls": [],
    "venueIds": [],
    "productIds": [],
    "language": "en",
    "currency": "EUR",
    "topRatedOnly": False,
    "hasDiscount": False,
    "sortType": "popularity",
    "includeExtraVenues": True,
    "includeAvailability": False,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/tiqets-attraction-and-ticket-price-finder-by-city").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 '{
  "mode": "search",
  "searchQuery": "eiffel tower",
  "searchQueries": [],
  "cities": [],
  "cityIds": [],
  "experienceTagIds": [],
  "startUrls": [],
  "venueIds": [],
  "productIds": [],
  "language": "en",
  "currency": "EUR",
  "topRatedOnly": false,
  "hasDiscount": false,
  "sortType": "popularity",
  "includeExtraVenues": true,
  "includeAvailability": false,
  "maxItems": 3
}' |
apify call nimbryxo-studio/tiqets-attraction-and-ticket-price-finder-by-city --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/tiqets-attraction-and-ticket-price-finder-by-city"
        }
    }
}
```

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/eaP60EzuXq1SnxG9n/builds/dZ3hQaYD2sBgMxsh4/openapi.json
