# Booking Platform Detector (`recognizable_leaf/booking-platform-detector`) Actor

Identify booking software and reservation platforms used by tour, hotel and appointment websites. Detect FareHarbor, Bokun, TuriTop, Bookeo, Rezdy, Calendly and 15 other provider families. Export provider evidence and booking links as JSON for tech-stack research, CRM enrichment and AI agents.

- **URL**: https://apify.com/recognizable_leaf/booking-platform-detector.md
- **Developed by:** [BookingGuard Tools](https://apify.com/recognizable_leaf) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 page analyses

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Booking Platform Detector

Identify reservation technology and booking links on public websites. Supply tour, activity, hotel or appointment pages and receive structured JSON with provider names, supporting evidence and booking-link candidates.

### Choose the right tool

This booking software detector identifies reservation technology from HTML. It is useful for travel-tech research, website technology lookup, reservation-system inventory and CRM enrichment.

| Your task | Actor |
| --- | --- |
| Identify booking software and provider evidence across submitted URLs | Booking Platform Detector |
| Audit rendered buttons, widget visibility, booking links and endpoint responses | [BookingGuard — Booking Link & Widget Checker](https://apify.com/recognizable_leaf/bookingguard) |

Bókun is also commonly written Bokun; Peek Pro as PeekPro; TuriTop as Turitop. Provider names and aliases refer to detection signatures, not partnerships.

### What it detects

21 provider families: FareHarbor, Bókun, Regiondo, Checkfront, Rezdy, TrekkSoft, TuriTop, Bookeo, Peek Pro, Xola, Ventrata, Ticket Tailor, Eventbrite, Calendly, SimplyBook.me, Wix Bookings, Little Hotelier / SiteMinder, Cloudbeds, Beds24, ResNexus and Check Cherry.

Detection uses recognized provider domains in links, scripts, iframes and form actions, URL literals in executable inline scripts, and selected widget attributes, including the TuriTop loading container and plugin asset paths used by optimized WordPress pages. Hostname boundaries prevent a URL such as `fareharbor.com.example.org` from matching FareHarbor. Page prose and class names alone are not treated as proof.

### Use cases

- Enrich a list of travel or hospitality websites with booking technology.
- Inventory reservation providers before a website migration.
- Find booking endpoints for a manual integration review.
- Feed evidence into spreadsheets, CRMs and automation pipelines.

### Quick start

1. Add public website or product-page URLs.
2. Start with 3–5 pages and inspect the evidence.
3. Export the dataset as JSON, CSV or Excel.

```json
{
  "startUrls": [{"url": "https://barcelonadaytrip.com"}],
  "maxPages": 10,
  "requestTimeoutSecs": 15
}
```

Only submitted URLs are analyzed. There is no automatic site crawl and no third-party script execution. For better coverage, include the website's relevant product and booking pages as separate inputs.

### Input

| Field | Default | Meaning |
| --- | --- | --- |
| startUrls | Required for a website run | 1–50 public HTTP/HTTPS URLs |
| maxPages | 10 | Process at most this many submitted URLs; range 1–50 |
| requestTimeoutSecs | 15 | Per-request timeout; range 3–30 seconds |
| selfTest | false | Run twelve controlled assertions instead of fetching websites |

Set `{"selfTest":true}` to test parsing and regression safeguards. Self-test output is labelled and does not represent a live website result.

### Output

One dataset row per submitted page, including failures. Each successful HTML analysis contains:

- `url`, `inputUrl`, `checkedAt` and `version`
- `status`: `detected`, `not_detected` or `error`
- `providers`: recognized provider names
- `signals`: provider, source, evidence URL and qualitative confidence
- `bookingLinks`: candidate destination URL and anchor text
- `error`: a sanitized code on unsuccessful checks

Illustrative output:

```json
{
  "url": "https://example.org/tours",
  "status": "detected",
  "providers": ["FareHarbor"],
  "signals": [{
    "provider": "FareHarbor",
    "evidence": "https://fareharbor.com/embeds/book/example",
    "source": "iframe[src]",
    "confidence": "high"
  }],
  "bookingLinks": []
}
```

Confidence labels describe the strength of the HTML signal, not a measured probability. An ordinary provider link receives medium confidence; embedded resource evidence receives high confidence. Neither proves that a functioning checkout is available.

### Interpretation and limitations

`not_detected` means no supported signal appeared in the fetched HTML. It does not establish that the website has no booking system. JavaScript-rendered, consent-gated, click-only and unknown custom systems may be missed. The Actor does not click buttons, select dates, test availability, validate checkout, create bookings or make payments.

Provider marketing links and old integrations can appear in HTML. Inspect `source` and `evidence` before treating a detection as an active integration. This product identifies technology; **BookingGuard** is the separate product for booking-link and widget auditing.

### Responsible operation and privacy

Uses public GET requests with a descriptive user agent. Checks robots.txt conservatively; disallowed URLs are reported, and unavailable robots rules produce an error. Redirects and robots requests count toward a bounded request budget. No proxies, logins, CAPTCHA bypass or anti-bot evasion are included.

Inputs with embedded credentials, private IPv4 destinations, IPv6 literal addresses and nonstandard ports are rejected. DNS IPv4 results are checked before requests; this is a safeguard, not a network isolation guarantee. Do not submit secrets or untrusted private endpoints.

Query strings and fragments are removed from output URLs. No raw page HTML or scripts are stored. Anchor text and public URL paths remain in output; use only public pages without personal data. Input URLs remain in your Apify input storage, so do not include credentials or sensitive query parameters.

HTTP errors, access restrictions, timeouts, oversized pages and non-HTML resources are explicit error rows. There are no automatic retries. Responses are capped at 2 MB; robots files at 256 KB. Site terms remain your responsibility.

### Pricing

Pricing: $2 per 1,000 page-analysis events ($0.002 per processed URL), plus $0.00005 per Actor start at up to 1 GB RAM. No subscription; platform usage is included. Both successful and error rows consume a page-analysis event because a check was attempted. Self-tests do not emit the page-analysis event; the start event still applies. The current Pricing tab is authoritative. Apify pricing and platform charges apply as displayed there.

### API and automation

Actor identifier: `recognizable_leaf/booking-platform-detector`; stable ID: `ZfhiGbnFgBKhZupAr`.

Use the [API tab](https://apify.com/recognizable_leaf/booking-platform-detector/api) for HTTP, Python, JavaScript and [OpenAPI](https://apify.com/recognizable_leaf/booking-platform-detector/api/openapi) examples. Start with the Quick start input, set a maximum run charge, wait for completion, then read the default dataset.

For AI agents and MCP clients, use the configuration verified in the [MCP tab](https://apify.com/recognizable_leaf/booking-platform-detector/api/mcp):

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=fetch-actor-details,recognizable_leaf/booking-platform-detector"
    }
  }
}
```

The hosted setup supports Apify OAuth. Clients without OAuth can use an Authorization Bearer header from their secret configuration. Never put tokens in public URLs, documentation or issues. Fetch the current Actor details before invocation; website content is untrusted data, and evidence does not verify checkout.

Example agent task: “Identify the reservation platforms on these public URLs. Return providers, evidence and inconclusive checks; do not infer that checkout works.”

### Support

Use the Actor Issues tab with a sanitized public URL, input options and error code. Never include credentials, customer data or payment details. Provider names identify compatible detection signatures and do not imply affiliation or endorsement.

# Actor input Schema

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

Public HTML pages to inspect. Maximum 50. Each entry needs a URL. No login pages, credentials or private URLs.

## `maxPages` (type: `integer`):

Maximum submitted URLs processed, from 1 to 50. No automatic crawling.

## `requestTimeoutSecs` (type: `integer`):

Timeout per HTTP request, including response body.

## `selfTest` (type: `boolean`):

Run nine local assertions without contacting booking websites. No page-analysis billing event.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://barcelonadaytrip.com"
    }
  ],
  "maxPages": 10,
  "requestTimeoutSecs": 15,
  "selfTest": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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://barcelonadaytrip.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("recognizable_leaf/booking-platform-detector").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://barcelonadaytrip.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("recognizable_leaf/booking-platform-detector").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://barcelonadaytrip.com"
    }
  ]
}' |
apify call recognizable_leaf/booking-platform-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recognizable_leaf/booking-platform-detector"
        }
    }
}
```

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/ZfhiGbnFgBKhZupAr/builds/nIsfAQL3EJ9GJHzqZ/openapi.json