# Klook Activity Availability & Prices (`boncross/klook-availability`) Actor

Scrape Klook availability and prices. Just add an activity URL or id and get every bookable date, time slot and ticket type with the exact price, remaining stock, sold-out flag and booking cut-off. Track price changes between runs. $0.50 per 1,000 slots.

- **URL**: https://apify.com/boncross/klook-availability.md
- **Developed by:** [BonCross API](https://apify.com/boncross) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 slot-listeds

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

## Klook Activity Availability & Prices

### What is Klook Activity Availability & Prices?

A Klook listing shows you one "from" price. Klook Activity Availability & Prices gets you the booking calendar behind it: the price of each ticket type on each date and time slot, and how many places are left. Paste an activity link and you get one row per date, slot and ticket type for every package that activity sells.

There are four BonCross actors for Klook, and this is the one for live inventory. [Klook Search Scraper](https://apify.com/boncross/klook-search) finds activities, [Klook Activity Details Scraper](https://apify.com/boncross/klook-activity-details) returns the full record of one, and [Klook Activity Reviews Scraper](https://apify.com/boncross/klook-reviews) collects what travellers wrote.

What you get here that a listing scrape can't give you:

- **The price for the day you care about.** On 7 October 2026 an adult 1-Day Ticket for Hong Kong Disneyland was US$78.69 for 8 October and US$90.50 for the 9th. The child and senior tickets moved too, from US$58.75 to US$67.95.
- **Places left, per slot.** The same run found 46 places on the 09:30 snorkelling boat from Sanur, Bali, and 68 on the 14:00.
- **A whole activity in seconds.** 25 activities with 71 packages over the next 14 days came to 3,646 rows in 10 to 12 seconds.
- **Change tracking that saves you money.** Name a price memory and a scheduled run returns only the slots whose price moved. Unchanged slots aren't charged.
- **$0.50 per 1,000 slots** on the Free plan and $0.35 on Business. That's the whole price: there's no proxy to set up and no usage bill on top.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 37 of 37 live checks on its inputs and filters passed on 8 October 2026
- 14 activities run on 7 October 2026, tickets, tours, passes and two sold out: 630 slots, 5 error rows
- Charges matched the rows: 31 packages, 630 slots
- A package with no bookable dates gets a row saying so

It also does these:

- Split a package that sells several ticket types into one row per type, with that type's price and stock
- Price combos whose parts are booked separately, such as a park ticket plus a dinner sitting
- Report the booking cut-off time for each slot
- Keep only bookable slots, or only a date range
- Quote prices in any currency Klook offers
- Add the price before a promotion, next to the price a buyer pays today
- Add each package's booking rules: fixed-date or flexible ticket, quantity per booking, age bands, cancellation terms
- Say whether a package is on sale, suspended or coming soon, with its launch time
- Tell you when a package has nothing on sale in your dates, in a row of its own

### What data do you get for each slot?

| | |
|---|---|
| 📅 Date | ⏰ Time slot |
| 💵 Exact price for that slot | 🎟️ Ticket type name and id |
| Each ticket type's own price on that date | Crossed-out retail price, where Klook shows one |
| 📦 Places remaining | 🚫 Sold-out flag |
| ✅ Bookable flag | ⏳ Booking cut-off time |
| Package id and package name | Activity id and 🔗 activity link |
| Slot id | 💱 Currency |
| Which ticket type the slot price belongs to | Presale flag |
| 📈 Price change since your last run | Previous price and when it was seen |
| Sale status: on sale, suspended or coming soon | Launch time of a coming-soon package |
| Combo flag, combo version and the combo's parts | Whether the product is booked by date or by time |
| Required ticket types and per-type quantity limits | Price before any promotion, and a promotion flag (optional) |
| Ticket type: fixed date, open or flexible (optional) | Minimum and maximum quantity per booking (optional) |
| Age band and booking terms per ticket type (optional) | Eligibility notes, such as free entry for under-3s (optional) |

### How to check availability on Klook

You don't need to write any code. It's a form, and the result opens as a table you can download.

1. [Create a free Apify account](https://console.apify.com/sign-up) and open [Klook Activity Availability & Prices](https://apify.com/boncross/klook-availability).
2. Paste the address of a Klook activity page, such as the Hong Kong Disneyland one. You can add as many as you like.
3. Set "Days ahead" (14 by default) and the currency you want prices in.
4. Press Start, then download the rows as Excel, CSV or JSON.

### ⬇️ Input

Paste an activity link, an activity id, or a package link. An activity is everything sold on one Klook page. A package is one option on that page, the thing you'd actually book. Give an activity and every package it sells is priced. Give a package link (the address with `?package_id=` in it) when you want only that option.

If you set no dates, you get the next 14 days. "Days ahead" changes that to the next N days, and 0 gives every date Klook has on sale, which for a big attraction can be thousands of rows. "From date" and "To date" keep a fixed window and take the place of "Days ahead".

Three limits apply to each activity or package separately: "Max packages per activity", "Max slots per package" and "Max dates per package". Ten packages at 50 slots each returns 500 rows. "Maximum results for the whole run" caps the run as a whole, and you're charged for nothing past it. All four default to 0, which means no limit.

#### Every package of one activity, bookable slots for the next fortnight

```json
{
  "activities": ["https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/"],
  "daysAhead": 14,
  "onlyAvailable": true
}
```

#### One package only, in Hong Kong dollars

```json
{
  "activities": ["https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/?package_id=349874"],
  "daysAhead": 30,
  "currency": "HKD"
}
```

#### A timed tour, with its booking rules

```json
{
  "activities": ["https://www.klook.com/en-GB/activity/122675-snorkeling-experience-in-nusa-penida-4-snorkeling-spots/"],
  "daysAhead": 3,
  "includeBookingRules": true
}
```

With "Booking rules" on, each row also has `ticketType`, `minQuantity`, `maxQuantity`, `eligibility`, `usageValidity` and `packageTerms` (on tours, the cancellation rule, for example "Free cancellation (24 hours notice)"). Timed tickets add `skuDescription` (the age band) and `skuTags` (terms such as cancellation). Leave it off and those columns are empty.

#### Today's price next to the price before the promotion

```json
{
  "activities": ["https://www.klook.com/en-GB/activity/3021-bangkok-must-visit-landmarks-day-tour/"],
  "daysAhead": 7,
  "maxPackagesPerActivity": 3,
  "includePriceBeforePromotion": true
}
```

Each price is the one Klook shows a buyer, with any current promotion applied. This option adds `priceBeforePromotion` (on the row that owns the slot price), `unitPriceBeforePromotion` and `isPromotion`.

#### A daily watch that reports only what moved

```json
{
  "activities": [
    "https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/?package_id=349874",
    "https://www.klook.com/en-GB/activity/69622-singapore-attractions-pass/"
  ],
  "daysAhead": 30,
  "priceStoreName": "klook-prices",
  "onlyNewOrChanged": true
}
```

| Field | Notes |
|---|---|
| `activities` | Activity links, activity ids or package links. |
| `startUrls` | The same links loaded in bulk from a file, a Google Sheet or a remote list. Combined with `activities`. |
| `daysAhead`, `dateFrom`, `dateTo` | The next N days (14 by default, 0 for every date on sale), or a fixed window as YYYY-MM-DD. `daysAhead` is used when both dates are empty. |
| `maxPackagesPerActivity`, `maxSlotsPerPackage`, `maxDates`, `maxItems` | The three per-target limits and the run-wide one. Default 0, no limit. |
| `onlyAvailable` | Drop sold-out rows. Default off. Filtered rows are free. |
| `includePerSkuStock`, `includeTicketTypePrices` | Each ticket type's own stock and its own price per date. Both on by default. |
| `includePriceBeforePromotion`, `includeBookingRules` | The two optional column groups above. Both off by default. |
| `dateLevel` | For passes with no real time slots: one row per date with an empty time. Default off. |
| `currency`, `language` | Default `USD` and `en_GB`. |
| `priceStoreName`, `onlyNewOrChanged` | The price memory, and returning only slots whose price moved. |
| `skipEmptyPackages`, `maxConcurrency`, `delayMs` | Advanced. See below. |

#### For developers

- A bare number is ambiguous, because activity ids and package ids share one number space. It's read as an activity first. To name one package beyond doubt, pass its link with `?package_id=…`.
- `includeTicketTypePrices` (default on) adds one lookup per date on packages that sell several ticket types. Off, the per-type price is empty and only the slot price is given. It changes the run time, not the price you pay.
- `includePerSkuStock` (default on) adds a second lookup on multi-type packages. Off, each ticket type still gets a row and shares the slot's stock.
- `includePriceBeforePromotion` adds one lookup per option, and `includeBookingRules` two per package.
- `skipEmptyPackages` (default on) drops, when an activity is expanded, the packages with nothing bookable in your date window before they're priced.
- `dateLevel` reports the stock summed across the day and the price of the cheapest slot still on sale.
- `maxConcurrency` (default 64, from 1 to 64) is how many requests run at once. `delayMs` (default 0, up to 10,000) adds a pause before each one. We'd leave both alone unless a run reports errors.
- `product-resolved` is charged for each package that's priced, including one whose rows are all filtered out and one with no bookable date in the window.
- `id` joins the slot and the ticket type, which makes it unique per row.
- If Apify moves a run to another server part-way through, it carries on where it stopped. Rows already delivered aren't written or charged again.
- Run statistics count the requests Klook refused and the retries.

### ⬆️ Output

You get one row per date, time slot and ticket type. This one is an adult 1-Day Ticket for Hong Kong Disneyland on 8 October 2026, taken with "Booking rules" on:

```json
{
  "input": "https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/",
  "id": "1791417600349874-828951580651",
  "url": "https://www.klook.com/en-GB/activity/39-activity/",
  "activityId": "39",
  "packageId": "349874",
  "packageName": "1-Day Ticket",
  "ticketType": "fixed_date",
  "ticketTypeCode": 1,
  "isCombo": false,
  "comboVersion": null,
  "minQuantity": 1,
  "maxQuantity": 12,
  "eligibility": ["Free for children aged 0-2"],
  "usageValidity": null,
  "packageTerms": null,
  "saleStatus": "on_sale",
  "saleStatusCode": 1,
  "saleStatusText": null,
  "onSaleFrom": null,
  "timeSlotMode": "by_date",
  "date": "2026-10-08",
  "timeSlot": "00:00:00",
  "arrangementId": "1791417600349874",
  "skuId": "828951580651",
  "skuName": "Adult",
  "priceType": 0,
  "price": 78.69,
  "priceText": "78.69",
  "unitPrice": 78.69,
  "unitPriceListed": 85.25,
  "skuMinQuantity": 0,
  "skuMaxQuantity": null,
  "isSkuRequired": false,
  "isSkuOnSale": true,
  "skuOnSaleFrom": null,
  "isSlotPriceSku": true,
  "stock": 9999,
  "isSoldOut": false,
  "isAvailable": true,
  "isPresale": false,
  "blockOutTime": "2026-10-08 11:00:00",
  "comboParts": null,
  "skuDescription": null,
  "skuTags": ["Instant confirmation", "Valid on the selected date", "Free cancellation before redemption"],
  "currency": "USD",
  "previousPrice": null,
  "previousScrapedAt": null,
  "priceChange": null,
  "priceChangePct": null,
  "scrapedAt": "2026-10-07T20:32:39.838Z"
}
```

A few columns need a word:

| Column | Meaning |
|---|---|
| `price`, `isSlotPriceSku` | Each slot has one headline price, and it belongs to one of its ticket types. `isSlotPriceSku` marks that row. On the other ticket types of the slot `price` is empty. |
| `unitPrice`, `unitPriceListed` | This ticket type's own price on that date, and its crossed-out retail price where Klook shows one. |
| `stock` | Places left, as Klook reports them. A date ticket for a big park reports a large round figure like the 9,999 above. A timed tour reports the real count for that departure. |
| `timeSlot` | `00:00:00` on a ticket sold by date and not by time. |
| `blockOutTime` | When booking closes for the slot. |
| `packageName` | Filled when the package was found from an activity link. A package link given directly leaves it empty. |
| `comboParts` | For a combo, the parts and the date and sitting of each. |
| `previousPrice`, `previousScrapedAt`, `priceChange`, `priceChangePct` | Empty until a price memory has seen the slot in an earlier run. |
| `error` | Present only on a row that reports a problem, such as a package with no bookable date in your window or an id Klook doesn't know. |

### How much does it cost to track Klook availability?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `product-resolved`, per package | $0.002 | $0.002 | $0.002 | $0.002 |
| `slot-listed`, per row returned | $0.0005 | $0.00045 | $0.0004 | $0.00035 |

Enterprise plans pay the Business price.

**$0.50 per 1,000 slots** on the Free plan, $0.35 on Business. Platform usage and proxy are included, and rows removed by a filter or unchanged since your last run are free.

- The Hong Kong Disneyland and Bali run described above (4 packages, 3 days, 54 rows): $0.002 + 4 × $0.002 + 54 × $0.0005 = **$0.037** ($0.0289 on Business).
- A large theme park with 26 packages over 14 days, 1,010 rows: $0.002 + 26 × $0.002 + 1,010 × $0.0005 = **$0.559** ($0.4075 on Business).
- A daily watch on one package that returns 60 changed slots: $0.002 + $0.002 + 60 × $0.0005 = **$0.034** ($0.025 on Business).

The $5 of credits that Apify's Free plan includes each month covers about 9,000 slots at the size of the second example, package fees included.

### How fast is it, and how far ahead can you look?

| Run | Rows | Time | Price |
|---|---|---|---|
| 25 activities (71 packages), next 14 days | 3,646 | 10 to 12 s | $1.97 |
| 25 activities (90 packages), next 60 days | 20,437 | 50 s | $10.40 |
| One large theme park (Universal Studios Japan, 26 packages), next 14 days, default options | 1,010 | 3 to 6 s | $0.559 |
| One ticket of that park (a package link), next 14 days | 42 | 2 s | $0.025 |
| A day tour (Mt Fuji) (9 packages), next 14 days | 160 | 4 s | $0.100 |

These are whole runs, start to finish, measured on 2 October 2026. A larger activity costs you little extra time, and an activity given as a bare id takes the same time as its link. Hundreds of activities over a full year of dates fit in one run.

How far ahead you can look is Klook's decision. The calendar lists only dates that are on sale, and a package with a 54-day sale window returns 54 dates.

### Watch prices and stock on a schedule

This data earns its keep when you collect it repeatedly. Put the run on an Apify Schedule, name a price memory, and each run tells you which slots changed price since the last one. A webhook can fire when the run ends, and the rows can go on to Google Sheets, Slack, Make or Zapier through Apify's integrations, which is enough for a "this date just reopened" alert.

From your own code, `POST https://api.apify.com/v2/acts/boncross~klook-availability/run-sync-get-dataset-items` with the input JSON as the body returns the rows in one call. The `apify-client` packages on npm and PyPI wrap the same API.

An AI agent can call it through the Apify MCP server at `mcp.apify.com`, where it appears as the tool `boncross/klook-availability`. Give the agent an activity link and ask which day next week is cheapest.

### FAQ

#### Do I need proxies or a Klook account?

Neither. There's nothing to configure, and no proxy charge on top of the per-row price.

#### Should I paste the activity page or a package?

Paste the activity page if you want everything it sells. Hong Kong Disneyland's page lists 28 packages, from the 1-Day Ticket to meal vouchers and annual memberships, and each one is priced. If you only want one of them, open it on Klook and paste the address once it shows `?package_id=`.

#### Why is `price` empty on some rows?

A slot has one headline price, and Klook attaches it to one ticket type. That row has `isSlotPriceSku: true`. The slot's other ticket types have their price in `unitPrice`, which is filled on each row.

#### Why did a date disappear between two runs?

Klook removes a date from the calendar once it sells out or leaves the sale window. A vanished date is a signal, and it's the one to alert on if you're watching for sell-outs. Single slots and ticket types can still appear as sold out.

#### What does a row with an `error` mean?

It tells you why something you asked for has no slots: a package with no bookable date in your window, a link that isn't a Klook activity, or an id Klook doesn't know. A package with no dates still pays its `product-resolved` fee, and the row itself is free. If Klook couldn't be read for an activity or a package on this run, the row tells you what happened and whether to run it again or check the id, and that input costs nothing. Airport transfers are sold outside Klook's activity pages, and an activity link for one returns a row saying so.

#### How do I get only the slots whose price changed?

Name a price memory ("Price memory store" in the form), switch on "Only new or changed", and use the same name on each run. The first run returns everything and fills the memory.

#### What are the limits?

- You only get dates inside a package's sale window. Nothing earlier or later exists to report.
- Combos whose parts are booked separately are priced for same-day combinations: one row per date, sitting and ticket type. Their stock is the lowest of the parts'.
- `timeSlotMode`, `isSkuOnSale` and `skuOnSaleFrom` are filled for dated tickets while per-ticket-type stock is on. Tours, passes and eSIMs leave them empty.
- Age bands and booking terms are published per ticket type on timed tickets. Tours, passes and eSIMs have the package-level rules only. `maxQuantity` and `skuMaxQuantity` are empty where Klook sets no limit.
- `unitPriceListed` is filled only where Klook shows a crossed-out price, 11% of rows in one sample of 630.
- Klook Pass activities are expanded into their options like any other activity (six Klook Passes tested, 204 options listed).
- A pass with no real time slot reports a single placeholder slot. Switch on "Date-level product" for one row per date and ticket type.
- Names are in English. The language setting hasn't been shown to change them.
- The per-ticket-type split has been measured on a handful of packages that sell more than one ticket type.
- Klook occasionally refuses requests for a short window at night, Japan time. The actor waits and retries.

#### Is it legal to scrape Klook?

The actor reads only what Klook serves to any visitor who isn't logged in: public prices and availability, with no personal data. Scraping public data is generally lawful, but how you use it is your responsibility, including Klook's terms and the law where you are.

### More from BonCross

- [Klook Activity Details Scraper](https://apify.com/boncross/klook-activity-details): Full Klook activity records.
- [Klook Activity Reviews Scraper](https://apify.com/boncross/klook-reviews): Every review Klook shows for an activity.
- [Trip.com Attraction Reviews Scraper](https://apify.com/boncross/tripcom-reviews): Trip.com reviews for any attraction.
- [KKday Product Availability & Prices](https://apify.com/boncross/kkday-availability): KKday availability and prices for any product.
- [Trip.com Hotel Search Scraper](https://apify.com/boncross/tripcom-hotel-search): Every hotel Trip.com lists for a destination and your dates.
- [Accor Hotel Details Scraper](https://apify.com/boncross/accor-hotel-details): Full Accor hotel records.

### Your feedback

Seen a slot on Klook that isn't in your rows, or a price that doesn't match the page? Tell us on the Issues tab in Apify Console, with the activity link and the date. We read every report and answer there.

# Changelog

This Actor's version history is a separate document: https://apify.com/boncross/klook-availability/changelog.md

# Actor input Schema

## `activities` (type: `array`):

Klook activity URLs or activity ids, or a package link (the address with ?package_id= in it). An activity is expanded into every package it sells, so you can paste the address of the page you are looking at, such as the Hong Kong Disneyland one.

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

Klook page addresses, with the option to load them in bulk from a file, a Google Sheet or a remote list. Use this when you have more links than you want to paste. Combined with anything in the list above.

## `maxPackagesPerActivity` (type: `integer`):

When an activity is expanded, price at most this many of its packages. 0 means all of them.

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

A run-wide ceiling across every target. The per-target limit above applies to each one separately, so ten targets at 50 each returns 500; set this to cap the total. Zero means no run-wide limit. Rows that report an input the actor could not resolve are not counted here and are never charged for.

## `maxSlotsPerPackage` (type: `integer`):

Stop after this many rows per package. 0 means no limit.

## `dateFrom` (type: `string`):

Earliest date to keep, as YYYY-MM-DD. When this or To date is set, Days ahead is not used.

## `dateTo` (type: `string`):

Latest date to keep, as YYYY-MM-DD. When this or From date is set, Days ahead is not used.

## `daysAhead` (type: `integer`):

Keep only dates within this many days from today. 14 by default. Set 0 for every date Klook has on sale. Not used when From date or To date is set.

## `dateLevel` (type: `boolean`):

For passes with no real time slots. Reports one row per date with an empty time.

## `maxDates` (type: `integer`):

Keep only the first N dates. 0 means no limit.

## `onlyAvailable` (type: `boolean`):

Drop sold-out rows. Filtered rows are free.

## `includePerSkuStock` (type: `boolean`):

On options that sell more than one ticket type, add a second lookup so each type gets its own remaining stock. Turn off to halve the requests.

## `includeTicketTypePrices` (type: `boolean`):

On packages that sell several ticket types (Adult, Child, Senior…), look up each type's price for every date returned, so each row carries the price that ticket type costs on that day. Prices of many attractions change by date, so without this the per-type price is left empty and only the slot price is given. Adds one lookup per date on multi-type packages.

## `includePriceBeforePromotion` (type: `boolean`):

Every price is the one Klook shows a buyer, with any current promotion applied. Turn this on to add, beside it, the price before the promotion for each time slot and ticket type (priceBeforePromotion, unitPriceBeforePromotion) and an isPromotion flag. Adds one lookup per option, so the run takes longer.

## `includeBookingRules` (type: `boolean`):

Add each package's booking rules to its rows: whether the ticket is for a fixed date or flexible, the minimum and maximum quantity per booking, eligibility notes such as free entry for young children, the package's usage validity and booking terms (on tours, its cancellation rule), and for timed tickets each ticket type's age band and booking terms (cancellation, confirmation). Sale status, combo flags and per-ticket-type quantity limits are included either way. Adds two lookups per package.

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

ISO currency code. Prices come back quoted in it. Default USD.

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

Klook locale code, such as en_GB, en_US or ja_JP. Package and ticket names come back in English whichever you pick.

## `priceStoreName` (type: `string`):

Name a key-value store and each run remembers the last price per slot, so rows carry the change since the previous run.

## `onlyNewOrChanged` (type: `boolean`):

Return only slots whose price moved since the last run. Needs a price memory store.

## `skipEmptyPackages` (type: `boolean`):

When an activity is expanded, drop the packages that have nothing bookable in your date window before pricing them. Saves requests on large activities.

## `maxConcurrency` (type: `integer`):

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## `delayMs` (type: `integer`):

Optional pause before each call, in milliseconds. 0 (the default) runs as fast as the parallel limit allows.

## Actor input object example

```json
{
  "activities": [
    "https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/?package_id=349874"
  ],
  "startUrls": [],
  "maxPackagesPerActivity": 0,
  "maxItems": 0,
  "maxSlotsPerPackage": 0,
  "dateFrom": "",
  "dateTo": "",
  "daysAhead": 14,
  "dateLevel": false,
  "maxDates": 0,
  "onlyAvailable": false,
  "includePerSkuStock": true,
  "includeTicketTypePrices": true,
  "includePriceBeforePromotion": false,
  "includeBookingRules": false,
  "currency": "USD",
  "language": "en_GB",
  "priceStoreName": "",
  "onlyNewOrChanged": false,
  "skipEmptyPackages": true,
  "maxConcurrency": 64,
  "delayMs": 0
}
```

# Actor output Schema

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

Klook availability: every row the run returned.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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 = {
    "activities": [
        "https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/klook-availability").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 = { "activities": ["https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/"] }

# Run the Actor and wait for it to finish
run = client.actor("boncross/klook-availability").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 '{
  "activities": [
    "https://www.klook.com/en-GB/activity/39-hong-kong-disneyland-park-ticket/"
  ]
}' |
apify call boncross/klook-availability --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,boncross/klook-availability"
        }
    }
}
```

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/ZBbIbt6ehWboMaCGT/builds/IhD0qMvZgA6SCvYEG/openapi.json