# Booking.com Real-Time Data Scraper (`b2b_leads/booking-real-time-data`) Actor

Get live hotel and accommodation data from Booking.com for any city or country — names, prices, star ratings, review scores, locations and more. Multi-destination runs process in parallel with filters, market breakdown and real-time webhooks. Paid Apify plans; free accounts get a small sample.

- **URL**: https://apify.com/b2b\_leads/booking-real-time-data.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 Real-Time Data

**Turn Booking.com into a clean, structured property and market-intelligence feed.** Discover hotels, apartments, villas, guest houses and more across multiple destinations in a single run — with names, links, descriptions, star ratings, guest review scores and counts, nightly "from" prices, coordinates, districts, cities and countries — delivered as **clean JSON** to your Apify dataset while the run is still going.

Built for travel and hospitality teams, lead-generation agencies, revenue managers, market researchers, real-estate and short-let investors, and AI/LLM workflows that need reliable Booking.com data without maintaining a brittle scraper of their own.

> **Free plan / paid plan:** this Actor is intended for paid Apify plans. Runs on a free Apify account are **restricted to a small sample of 2 results per run** and log a clear message inviting you to upgrade. Upgrade to a paid plan for full, unlimited data. See [Free plan & paid plans](#free-plan--paid-plans).

***

### Why this Actor

| | Booking Real-Time Data | Typical DIY scraper |
|---|------------------------|---------------------|
| **Setup** | Organized input UI, run immediately | Fragile scripts to maintain |
| **Speed** | **Up to 4 destinations processed in parallel** | One destination at a time |
| **Memory** | **512 MB** default — records written as they arrive | High memory, everything held until the end |
| **Reliability** | Retries, session rotation and graceful recovery built in | Breaks on the first hiccup |
| **Output** | Consistent, LLM-ready JSON | Inconsistent formats per source |
| **Scale** | Many destinations per run | Usually one destination at a time |
| **Market data** | Stars, review scores, review counts, prices, coordinates | Rarely normalized |
| **Delivery** | Dataset + optional real-time webhook | Manual export |
| **Insight** | Optional destination/market breakdown | None |

***

### What you get

Every record is tagged with `featureType` (`property` or `destination`) and `scrapedAt`, so you can filter, join and pipeline the data anywhere.

#### Property records — `featureType: "property"`

| Field | Description |
|-------|-------------|
| `name` | Property name |
| `propertyId` | Booking.com property identifier |
| `url`, `sourceUrl` | Link to the property's Booking.com listing |
| `description` | Property summary when the destination provides one |
| `image` | Cover image link |
| `propertyType` | Property type when shown (e.g. `Hotel`, `Apartment`, `Villa`) |
| `starRating` | Star rating as shown |
| `reviewScore` | Guest review score (0–10) |
| `reviewCount` | Number of guest reviews |
| `priceFrom`, `priceDisplay`, `currency` | Lowest nightly "from" price where shown |
| `address` | Street address when the destination provides one |
| `district` | District / neighbourhood / area |
| `city`, `countryCode` | Location breakdown |
| `latitude`, `longitude` | Coordinates for mapping and geo filters |
| `isPreferred` | Whether the property is a preferred partner |
| `reviewHighlight` | `{ author, countryCode, score, text }` — a recent guest review snippet when shown |
| `searchDestination` | The input destination that produced this record |
| `scrapedAt` | Record timestamp |

#### Destination records — `featureType: "destination"`

Emitted when **Include market breakdown** is enabled.

| Field | Description |
|-------|-------------|
| `name` | Destination name (city, region, landmark or airport) |
| `type` | `city`, `region`, `landmark` or `airport` |
| `countryCode` | Country code |
| `url` | Destination link |
| `hotelsCount` | Number of properties available in that destination |
| `image` | Destination image link |
| `searchDestination` | The input destination that produced this record |
| `scrapedAt` | Record timestamp |

New records are written to the dataset **as they are collected** — long runs stay light in memory and you can start consuming results before the run finishes.

***

### Features

#### 🏨 Property Discovery — on by default

Discover properties for any number of destinations in one run. Each row is a **destination**, and it accepts:

- a common **city name** (e.g. `Lisbon, Portugal`, `New York, USA`, `Bangkok, Thailand`),
- a **country name** (e.g. `Portugal`, `Spain`, `Japan`, `United Arab Emirates`), or
- a full **destination link**.

Add as many rows as you like. Turning on **Include market breakdown** also returns the nearby destinations that make up a country or region, with the number of properties in each — ideal for planning where to expand next.

#### 🎯 Filters

Narrow results before they reach your dataset:

- **Minimum star rating** — keep only properties at or above a star level.
- **Minimum review score** — keep only well-reviewed properties (0–10).
- **Minimum review count** — filter out properties without enough social proof.

Perfect for building shortlists of premium or proven properties.

#### 🗺️ Market breakdown

For country-level inputs, get the cities, regions, landmarks and airports that make up the market together with their inventory sizes — a fast way to size a market before you commit to a full scan.

#### 🔔 Real-time webhooks

Every record is **always saved to the dataset**. Optionally add a webhook URL and each new record is **also POSTed in real time** to your CRM, Slack, Zapier, Make, n8n or Google Sheets. Choose `json` (full record) or `slack` (ready-to-post Slack message).

#### 🌐 Connection

Runs use the built-in Apify residential proxy (US) by default, configurable in the **Connection** section if you need a different country or your own proxy URLs.

***

### Use cases

- **Hotel lead generation** — every property in a market with links, ratings and prices, ready for outreach.
- **Travel agency shortlists** — curated lists filtered by star rating and review score.
- **Revenue & pricing research** — compare nightly "from" prices across destinations and property types.
- **Market sizing** — use the market breakdown to see how many properties exist per city or region.
- **Hospitality SaaS prospecting** — find hotels by market for PMS, booking engines, marketing and operations tools.
- **Real-estate & short-let investment** — map property density, districts and coordinates for a target area.
- **Competitor set building** — assemble a comparable set of properties per destination and compare ratings.
- **Multi-market expansion** — one run across dozens of city + country combinations.
- **Reputation benchmarking** — track star ratings and review counts across a market.
- **Territory planning** — join coordinates to geographic and territory analysis.
- **Data enrichment** — start from a destination list and backfill structured property profiles.
- **AI & LLM pipelines** — JSON records for RAG, scoring, outreach drafts and market summaries.
- **Warehouse & BI feeds** — scheduled runs feeding dashboards and data warehouses.
- **Travel alerts & monitoring** — watch a destination on a schedule and see what changes.

#### Scenario: hotel outreach list for a sales team

1. Enable **Property Discovery** with destinations `Lisbon, Portugal` and `Porto, Portugal`.
2. Turn on **Filters** → minimum star rating `4`, minimum review score `8`.
3. Run. Stream the dataset into your CRM, or set a webhook for real-time delivery.

#### Scenario: country-level market scan

1. Enable **Property Discovery** with destination `Spain`.
2. Turn on **Include market breakdown**.
3. Run. You get properties plus the cities and regions that make up the Spanish market and their inventory sizes.

#### Scenario: premium shortlist in one city

1. Destination `Dubai, United Arab Emirates`.
2. Filters → star rating `5`, review score `9`, review count `500`.
3. Run and export straight to Excel.

***

### Output reference

Each dataset row is one record. Filter by `featureType`:

| `featureType` | Description |
|---------------|-------------|
| `property` | A property discovered for a destination |
| `destination` | A nearby destination and its property inventory size |

**Traceability:** `searchDestination` records which input destination produced each record; `sourceUrl` is the property's own listing link.

Export formats: **JSON**, **CSV**, **Excel**, **XML**, **RSS** or via the **Apify API**.

***

### Input reference

Enable only what you need.

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| **🏨 Property Discovery** | | | |
| `enableListingDiscovery` | boolean | `true` | Discover properties by destination |
| `listingTasks` | object\[] | 2 example rows | `{ destination, maxItems? }` per destination |
| `minStarRating` | number | — | Minimum star rating (0–5) |
| `minReviewScore` | number | — | Minimum guest review score (0–10) |
| `minReviewCount` | integer | — | Minimum number of guest reviews |
| `includeMarketBreakdown` | boolean | `false` | Also output nearby destinations with inventory size |
| **⚙️ Output & limits** | | | |
| `maxItems` | integer | `1000` | Global cap on dataset rows across all destinations |
| `webhookUrl` | string | — | Optional real-time POST URL (dataset is always written) |
| `webhookFormat` | enum | `json` | `json` (full record) or `slack` (Slack message) |
| **🌐 Connection** | | | |
| `proxyConfiguration` | object | residential US | Apify proxy settings |

Full schema: see `.actor/input_schema.json` or the **Input** tab on Apify Console.

***

### Webhook delivery (optional)

Every record is **always saved to the Apify dataset first**. If you set `webhookUrl`, each new record is **also POSTed in real time** to your endpoint — ideal for CRMs, Slack, Zapier, Make or custom pipelines.

| Setting | Description |
|---------|-------------|
| `webhookUrl` | Your endpoint (http/https). Leave empty to use the dataset only. |
| `webhookFormat` | `json` — full property or destination object. `slack` — compact Slack incoming-webhook message. |

Webhook delivery is **best-effort**: a failed webhook never stops the run or prevents dataset writes.

**Example — discovery with Slack alerts**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [{ "destination": "Lisbon, Portugal", "maxItems": 50 }],
  "minStarRating": 4,
  "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
  "webhookFormat": "slack"
}
```

**Example — lead export with JSON webhook**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [{ "destination": "Barcelona, Spain", "maxItems": 100 }],
  "minReviewScore": 8,
  "webhookUrl": "https://your-crm.example.com/api/leads",
  "webhookFormat": "json"
}
```

***

### Quick start examples

**Two-city property list**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [
    { "destination": "Lisbon, Portugal", "maxItems": 100 },
    { "destination": "Porto, Portugal", "maxItems": 100 }
  ],
  "minStarRating": 4,
  "minReviewScore": 8
}
```

**Country market scan with breakdown**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [{ "destination": "Spain", "maxItems": 200 }],
  "includeMarketBreakdown": true
}
```

**Premium shortlist**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [{ "destination": "Dubai, United Arab Emirates", "maxItems": 150 }],
  "minStarRating": 5,
  "minReviewScore": 9,
  "minReviewCount": 500
}
```

**From a destination link**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [{ "destination": "https://www.booking.com/city/fr/paris.html", "maxItems": 150 }]
}
```

**API quick start**

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "enableListingDiscovery": true,
    "listingTasks": [
      { "destination": "Lisbon, Portugal", "maxItems": 100 },
      { "destination": "Barcelona, Spain", "maxItems": 100 }
    ],
    "minStarRating": 4
  }'
```

Dataset items: `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`

***

### LLM & MCP integration

Output is **JSON Lines–friendly structured data** — ideal for ChatGPT, Claude, Gemini, LangChain, LlamaIndex and custom agents.

#### Recommended workflow

1. Run the Actor with the destinations and filters you need.
2. Fetch dataset items via the [Apify API](https://docs.apify.com/api/v2) or export JSON/CSV.
3. Pass records to your LLM with a system prompt, or index them into a vector store.

#### Example: one property for an LLM prompt

```json
{
  "featureType": "property",
  "name": "1904 Benfica Hotel FLH Hotels",
  "propertyType": "Hotel",
  "starRating": 4,
  "reviewScore": 9.3,
  "reviewCount": 1352,
  "priceFrom": 199.7,
  "priceDisplay": "$200",
  "currency": "USD",
  "district": "Santa Maria Maior",
  "city": "Lisbon",
  "countryCode": "PT",
  "latitude": 38.7156444,
  "longitude": -9.1402479,
  "url": "https://www.booking.com/hotel/pt/1904-benfica-flh-hotels.html",
  "searchDestination": "Lisbon, Portugal"
}
```

#### Apify MCP (Model Context Protocol)

Use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants can **run** this Actor from natural language, **read** its dataset directly in chat, and **chain** it with other Actors (collect → filter → score → outreach).

```
User: "Find 4-star-plus hotels in Lisbon with great reviews and summarise them for a sales campaign"
→ MCP runs the Actor with listingTasks=[{destination:"Lisbon, Portugal"}], minStarRating=4, minReviewScore=8
→ MCP reads dataset items
→ LLM summarises each property and drafts outreach
```

***

### Connection & performance

- Apify's built-in residential proxy (US) is enabled by default — no extra setup.
- **Parallel processing:** up to **4 destinations are processed at the same time**, so a multi-destination run takes a fraction of the time of processing them one after another.
- Default memory is **512 MB**, enough headroom for large runs. Increase memory for very large multi-destination jobs.
- Records are delivered to the dataset as they are collected, so long runs do not accumulate data in memory.
- Automatic retries with rotating connections and randomized delays keep long runs stable without any tuning.
- A destination that cannot be loaded is skipped, so one bad destination never stops the run.
- Collection covers several data sets per destination and adds a little extra time per destination, giving richer records without a heavy memory footprint.

***

### Free plan & paid plans

This Actor is designed for paid Apify plans. Free-plan runs never crash or return a system error — they finish cleanly and explain the limit.

| Plan | What you get |
|------|--------------|
| **Free plan** | A small sample of up to **2 results** per run, plus a clear log message inviting you to upgrade. |
| **Paid plan** (Bronze and above) | Full, uncapped output with every feature. |

The restriction is always stated transparently: the run log shows the limit and the run summary (`OUTPUT`) reports the paywall state (`detected`, `isPaying`, `pricingTier`, `limited`, `blocked`), so the upgrade path is visible without any guesswork.

> Owners can tune the free sample with the `FREE_TIER_MODE`, `FREE_TIER_MAX_ITEMS` and `FREE_TIER_MAX_USERS_PER_ACCOUNT` environment variables (see `DEVELOPMENT.md`). `FREE_TIER_MODE=block` exports nothing instead of a sample.

***

### Integrations

- **CRMs** — push each record to HubSpot, Salesforce, Pipedrive or Airtable via webhook.
- **Automation** — Zapier, Make and n8n can trigger runs and consume the dataset or webhook.
- **Slack / Teams** — use `webhookFormat: "slack"` for instant alerts on new finds.
- **Sheets & BI** — schedule runs and pull the dataset into Google Sheets, Looker Studio, Power BI or a warehouse.
- **AI agents** — run through the Apify MCP server from Claude, ChatGPT or your own agent.

***

### Who it's for

- **Sales & lead-gen teams** building targeted hospitality outreach lists.
- **Travel agencies & tour operators** assembling and comparing property shortlists.
- **Revenue managers & analysts** benchmarking prices and ratings by market.
- **Hospitality SaaS & service providers** finding prospects by destination.
- **Real-estate & short-let investors** mapping property density and location.
- **Market researchers** sizing destinations and tracking reputation signals.
- **Data & AI engineers** feeding clean, structured JSON into pipelines and LLMs.

***

### Limitations & compliance

- Data is limited to what Booking.com publicly displays for each property.
- Some destinations return fewer properties than your limit, and some fields (for example price or address) are only present when the destination provides them.
- Prices are the lowest displayed "from" price at the time of the run and change frequently.
- Not affiliated with, endorsed by, or sponsored by Booking.com. Use responsibly and comply with applicable laws and Booking.com's Terms of Service. Always respect rate limits and local regulations when collecting property data.

***

### FAQ

**I got fewer results than `maxItems`.**
`maxItems` is a ceiling. Each destination also has its own `maxItems`, filters reduce the pool further, and some destinations display fewer properties.

**How do I collect an entire country?**
Set the destination to the country name (e.g. `Spain`) and enable **Include market breakdown** to also see its cities and regions with their inventory sizes.

**Can I use a destination that isn't a common city?**
Yes — use its country name, or paste the destination's Booking.com link. Common city names are supported out of the box.

**Why are some fields empty on some rows?**
Different destinations expose different details. Where a value isn't shown, the field is `null` rather than guessed.

**Does the webhook replace the dataset?**
No. The dataset is always written. The webhook is an additional real-time push.

**Can I run this on a schedule?**
Yes. Create an Apify Schedule with your saved input and results land in a fresh dataset each run.

**Will the free plan work for a quick test?**
Yes — free accounts receive a small sample of 2 results and an upgrade message. Paid plans receive the full output.

***

### Contact & custom work

Need something beyond this Actor? I build **custom scrapers**, **data pipelines**, and **full-stack web applications** for startups and enterprises.

- **Email:** <dubem115@gmail.com>
- **GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Reach out for:

- Custom Apify Actors (any website or data source)
- Travel / hospitality / local lead-gen data projects at scale
- LLM & MCP integrations with your data stack
- Web apps, dashboards and automation tools

***

*Booking Real-Time Data · by [DrunkCodes](https://github.com/DrunkCodes)*

# Actor input Schema

## `enableListingDiscovery` (type: `boolean`):

Discover properties by destination. Enabled by default.

## `listingTasks` (type: `array`):

One row per destination. A destination accepts a common city name (e.g. "Lisbon, Portugal", "New York, USA"), a country name (e.g. "Portugal", "Spain", "United States"), or a full Booking.com destination link.

## `minStarRating` (type: `number`):

Only keep properties rated at least this many stars (0–5). Leave empty for no limit.

## `minReviewScore` (type: `number`):

Only keep properties with a guest review score of at least this value (0–10). Leave empty for no limit.

## `minReviewCount` (type: `integer`):

Only keep properties with at least this many guest reviews. Leave empty for no limit.

## `includeMarketBreakdown` (type: `boolean`):

Additionally output nearby destinations (cities, regions, landmarks, airports) with their property inventory size. Useful for country-level market scans.

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

Global cap on dataset rows for this run across all destinations. Set it high for large runs. NOTE: on the Apify free plan this Actor is limited to a small sample of 2 results per run; upgrade to a paid Apify plan for full, unlimited output. See the README 'Free plan & paid plans' section.

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also POSTed to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

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

Apify residential proxy (US) is enabled by default for reliable collection.

## Actor input object example

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [
    {
      "destination": "Lisbon, Portugal",
      "maxItems": 50
    },
    {
      "destination": "Paris, France",
      "maxItems": 50
    }
  ],
  "includeMarketBreakdown": false,
  "maxItems": 1000,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every record from all enabled features in this run.

## `properties` (type: `string`):

Properties discovered across all destinations.

## `destinations` (type: `string`):

Nearby destinations and their property inventory size.

## `runSummary` (type: `string`):

Per-run metadata: record counts by type, errors, spending-limit status and paywall information.

# 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 = {
    "enableListingDiscovery": true,
    "listingTasks": [
        {
            "destination": "Lisbon, Portugal",
            "maxItems": 50
        },
        {
            "destination": "Paris, France",
            "maxItems": 50
        }
    ],
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/booking-real-time-data").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 = {
    "enableListingDiscovery": True,
    "listingTasks": [
        {
            "destination": "Lisbon, Portugal",
            "maxItems": 50,
        },
        {
            "destination": "Paris, France",
            "maxItems": 50,
        },
    ],
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/booking-real-time-data").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 '{
  "enableListingDiscovery": true,
  "listingTasks": [
    {
      "destination": "Lisbon, Portugal",
      "maxItems": 50
    },
    {
      "destination": "Paris, France",
      "maxItems": 50
    }
  ],
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/booking-real-time-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/booking-real-time-data"
        }
    }
}
```

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/AldEoSiqYRebJewBc/builds/YCVHaTTRPGvAZBwfn/openapi.json