# Booking Gap Lead Finder (`warbling_orzo/booking-gap-lead-finder`) Actor

Find qualified local-business website gaps for booking, ordering, chat, payment, and website sales opportunities.

- **URL**: https://apify.com/warbling_orzo/booking-gap-lead-finder.md
- **Developed by:** [Adrian Walczak](https://apify.com/warbling_orzo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 analysed websites

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

### What does Booking Gap Lead Finder do?

**Booking Gap Lead Finder** checks the websites of local businesses (salons, clinics, restaurants, garages, studios and similar) and tells you which of them have a gap you can sell into: **no online booking, no online ordering, no live chat or WhatsApp, no online payments**. Give it a list of website URLs and get back a scored, evidence-backed list of sales opportunities.

It works on public pages only and uses fixed detection rules instead of an LLM, so the same site always gives the same result and every finding comes with the page it was found on.

### Who is it for?

- Agencies and freelancers selling **booking systems, online ordering, chatbots, WhatsApp setups or website redesigns** to local businesses.
- Sales teams that want to skip businesses that already have a booking tool (Booksy, Fresha, Calendly, Reservio, Bookero and others are recognised).
- Anyone building a prospect list who is tired of lead lists that only say a business exists.

### What data do you get?

For every website you provide:

- **Booking status**: `detected`, `notDetectedOnScannedPages` or `unknown`, plus the provider name (for example Booksy, Fresha, Calendly) and the evidence URL and snippet.
- **Online ordering, contact form, live chat, WhatsApp and payment signals.**
- **Opportunity score (0-100) and level** for the service you sell, with a plain-language list of reasons.
- Contact details found on the site (emails, phone numbers, contact form URLs), social profile links and the website technology (WordPress, Shopify, Wix and others).
- Uncertainty notes, so you know when a result is only "not found on the pages we scanned".

English and Polish booking wording is understood ("Book now", "Zarezerwuj wizytę", "Umów się online", "e-Rejestracja" and similar). Pages that only say "call to book" are not counted as online booking.

### How to use it

1. Paste website URLs into **Business website URLs**.
2. Choose the service you sell in **Offered service**; this changes how the score is calculated.
3. Press **Start** and download the results as JSON, CSV or Excel, or connect the dataset to your CRM through the API or integrations.

#### Input example

```json
{
    "businessUrls": ["https://example-salon.com", "https://example-garage.com"],
    "offeredService": "bookingSystem",
    "analyzeInternalPages": true,
    "maximumInternalPages": 3,
    "includeContacts": true,
    "includeEvidence": true
}
```

| Field | Description |
| --- | --- |
| `businessUrls` | Website addresses to analyse. |
| `offeredService` | `bookingSystem`, `onlineOrdering`, `liveChat`, `websiteRedesign`, `onlinePayments` or `generalConversion`. |
| `maximumBusinesses` | Upper limit for one run (1-200). |
| `analyzeInternalPages` / `maximumInternalPages` | Also scan up to 5 internal pages, such as contact, services or price list. Default is 3. |
| `useBrowserFallback` | Use a real browser for sites that need JavaScript to show content. |
| `includeEvidence` | Include the page URL and snippet behind each finding. |

#### Output example

```json
{
    "businessName": "Example Salon",
    "website": "https://example-salon.com",
    "analysisStatus": "completed",
    "booking": { "status": "notDetectedOnScannedPages", "providers": [], "evidence": [] },
    "liveChat": { "detected": true, "providers": ["Facebook Messenger"] },
    "opportunityScore": 65,
    "opportunityLevel": "medium",
    "opportunityReasons": [
        "No online booking system detected on 3 scanned pages",
        "Business has a public phone number",
        "Website text suggests appointment-based services"
    ],
    "uncertainties": ["A feature may exist on a page that was not scanned."]
}
```

### How much does it cost?

The Actor uses **pay-per-event** pricing: you pay a small fixed amount for each analysed website, and nothing else. Check the current price on the Pricing tab. Runs are quick, because most sites are analysed from plain HTML without a browser.

### Limitations

- "Not detected" means no signal was found on the pages scanned. A booking tool hidden behind a login, an app or a page that was not scanned can be missed. Raise `maximumInternalPages` to scan more.
- Sites that block automated requests (for example Cloudflare challenges) are returned as `unknown` instead of guessing.
- Marketplaces and directories (such as booking platforms themselves) are recognised and are not scored as sales leads.
- Payment detection is conservative: many checkouts only appear after several steps that the Actor does not follow.

### Is it legal to use?

The Actor reads only publicly available website content and does not log in or bypass protection. Do not use the output to collect private personal data, and follow the marketing and data-protection rules (for example GDPR and e-privacy rules for cold email) that apply in your country.

### Support

Found a site that is classified wrongly? Open an issue on the Issues tab with the URL and what you expected, and detection rules can be adjusted.

# Actor input Schema

## `businessUrls` (type: `array`):

Website URLs of the local businesses to analyze, one per line.

## `maximumBusinesses` (type: `integer`):

Maximum number of businesses to analyze in one run.

## `offeredService` (type: `string`):

The service you want to sell. Scoring rules change based on this selection.

## `analyzeInternalPages` (type: `boolean`):

When enabled, the Actor scans prioritized same-domain pages such as contact, booking, services, menu, order, and checkout.

## `maximumInternalPages` (type: `integer`):

Maximum number of internal pages to scan per business in addition to the home page.

## `useBrowserFallback` (type: `boolean`):

Use one selective Playwright fallback attempt when a page is blocked or appears to require JavaScript rendering.

## `includeContacts` (type: `boolean`):

Extract public business emails, phone numbers, form URLs, and social profile links from scanned pages.

## `includeEvidence` (type: `boolean`):

Include evidence URLs and snippets for detected signals in the dataset output.

## `debugMode` (type: `boolean`):

Reserved for verbose local troubleshooting. Secrets and authorization headers are never logged.

## Actor input object example

```json
{
  "businessUrls": [
    "https://www.example.com"
  ],
  "maximumBusinesses": 25,
  "offeredService": "bookingSystem",
  "analyzeInternalPages": true,
  "maximumInternalPages": 3,
  "useBrowserFallback": true,
  "includeContacts": true,
  "includeEvidence": true,
  "debugMode": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "businessUrls": [
        "https://www.example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("warbling_orzo/booking-gap-lead-finder").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 = { "businessUrls": ["https://www.example.com"] }

# Run the Actor and wait for it to finish
run = client.actor("warbling_orzo/booking-gap-lead-finder").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 '{
  "businessUrls": [
    "https://www.example.com"
  ]
}' |
apify call warbling_orzo/booking-gap-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,warbling_orzo/booking-gap-lead-finder"
        }
    }
}
```

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/Ew4Hqjx5XBDswSSnr/builds/bfOIZFzckzXU3eBEM/openapi.json