# Tripadvisor Real-Time Data Scraper (`b2b_leads/tripadvisor-real-time-data`) Actor

Get fresh Tripadvisor business data: restaurants, hotels & attractions with names, phones, addresses, ratings, review counts, cuisine, websites and contact emails. Filter leads, collect multiple markets at once, and deliver results to your tools instantly via webhook. Free plan: 2-result sample.

- **URL**: https://apify.com/b2b\_leads/tripadvisor-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 $2.50 / 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

## Tripadvisor Real-Time Data

**Turn Tripadvisor into a clean, structured lead and market-intelligence feed.** Collect restaurants, hotels and attractions across multiple markets in a single run — with phone numbers, addresses, coordinates, ratings, review counts, cuisines, descriptions, contact emails and websites — all delivered as **clean JSON** to your Apify dataset as the run progresses.

Built for lead-generation agencies, hospitality and travel teams, market researchers, and AI/LLM workflows that need reliable Tripadvisor data without maintaining a brittle scraper.

> **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** 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

| | Tripadvisor Real-Time Data | Typical DIY scraper |
|---|---------------------------|---------------------|
| **Setup** | Organized input UI, run immediately | Fragile scripts to maintain |
| **Memory** | **512 MB** default — results written as they arrive | 2–4 GB+, everything held until the end |
| **Speed** | Fast structured output | Often slow and unreliable |
| **Output** | Consistent, LLM-ready JSON | Inconsistent formats |
| **Scale** | Large runs, many markets per run | Usually one query at a time |
| **Lead data** | Phones, emails, websites, ratings | Rarely normalized |
| **Delivery** | Dataset + optional real-time webhook | Manual export |
| **Reliability** | Runs reliably out of the box | Needs constant babysitting |

***

### What you get

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

#### Business records — `featureType: "listing"` or `"place"`

| Field | Description |
|-------|-------------|
| `name` | Business name |
| `category` | `restaurant`, `hotel` or `attraction` |
| `url` | Tripadvisor listing link for the business |
| `telephone` | Phone number when published |
| `email`, `emails[]` | Contact email(s) when the business publishes one |
| `website`, `websites[]` | External website(s) |
| `address`, `city`, `region`, `postalCode`, `country` | Full location breakdown |
| `latitude`, `longitude` | Coordinates for mapping and geo filters |
| `rating`, `reviewCount` | Reputation signals |
| `priceRange` | Price tier when shown |
| `cuisine[]` | Cuisine tags (restaurants) |
| `description` | Business summary |
| `geoId`, `placeId` | Tripadvisor identifiers |
| `marketLabel` | The market row that produced this record |
| `sourceUrl` | The business's Tripadvisor link |
| `scrapedAt` | Record timestamp |

#### Review records — `featureType: "review"`

| Field | Description |
|-------|-------------|
| `businessName`, `businessUrl` | The reviewed business |
| `author`, `authorLocation`, `authorContributions` | Reviewer identity |
| `rating` | Star rating (1–5) |
| `title`, `text` | Review headline and body |
| `date` | Review date |
| `tripType` | Trip type when shown |
| `helpfulVotes` | Helpful votes |
| `scrapedAt` | Record timestamp |

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

***

### Features

#### 🏪 Listing Discovery — on by default

Discover restaurants, hotels or attractions for any number of markets in one run. Each market row is a **category + location**. Location accepts:

- a common city name (e.g. `New York`, `London`, `Paris`, `Las Vegas`),
- a numeric **Tripadvisor geo ID** (e.g. `60763`) for any market worldwide, or
- a full **Tripadvisor market link**.

#### 🎯 Lead details

The **Lead details** switch collects the full profile for every business found — address details, coordinates, rating, description and contact details (phone, website, email where the business publishes one). **Every business is always included in the results**; a field simply stays empty when a business does not have that detail, so your dataset is always complete and predictable. Turn it off for a faster, lighter run with business names and links only.

#### 📍 Place Details

Already have a list of Tripadvisor business links? Paste them in and each one is returned as a complete structured profile.

#### ⭐ Reviews

Collect reviews for specific business links — author, rating, date, trip type, text and helpful votes. Each review is its own dataset row linked to the business, ideal for sentiment analysis and competitor monitoring.

#### 🔔 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

- **Restaurant lead generation** — every restaurant in a city with phone, email, website, rating and cuisine.
- **Hospitality prospecting** — hotels by market for suppliers, SaaS and service providers.
- **Attraction & tourism research** — map attractions, their ratings and review volume per destination.
- **Multi-market expansion** — one run across dozens of city + category combinations.
- **Competitor intelligence** — compare ratings, review counts and price ranges across a category.
- **Review mining & sentiment** — pull review text for LLM sentiment scoring, pain-point extraction and positioning.
- **Reputation monitoring** — track review volume and rating for your own or competitors' locations.
- **Local market mapping** — join coordinates to geographic/territory analysis.
- **Email outreach lists** — filter to businesses with a discovered email, then push straight to your CRM.
- **Data enrichment** — start from a link list and backfill structured business profiles.
- **AI & LLM pipelines** — JSON records for RAG, scoring, outreach drafts and territory summaries.
- **Warehouse & BI feeds** — scheduled runs feeding dashboards and data warehouses.

#### Scenario: restaurant lead list for a sales team

1. Enable **Listing Discovery** with markets `restaurants / Austin`, `restaurants / Dallas`.
2. Keep **Lead details** on, then filter by `telephone`/`email` in your CRM or spreadsheet after the run.
3. Run. Stream the dataset into your CRM, or set a webhook for real-time delivery.

#### Scenario: hotel competitor benchmark

1. Enable **Listing Discovery** with markets `hotels / Las Vegas`, `hotels / Miami`.
2. Compare `rating`, `reviewCount` and `priceRange` across the markets.

#### Scenario: review sentiment for a destination

1. Enable **Reviews** and paste business links.
2. Set `maxReviewsPerPlace` to 100 and feed the review text into your LLM.

***

### Output reference

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

| `featureType` | Description |
|---------------|-------------|
| `listing` | Business found through Listing Discovery |
| `place` | Business enriched from a specific link (Place Details) |
| `review` | A single review linked to a business |

**Traceability:** `marketLabel` records which market row produced the business; `sourceUrl` is the business's Tripadvisor link.

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

***

### Input reference

Enable only what you need — all features are independent.

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| **🏪 Listing Discovery** | | | |
| `enableListingDiscovery` | boolean | `true` | Discover businesses by category + market |
| `listingTasks` | object\[] | 2 example rows | `{ category, location, maxItems? }` per market |
| `maxPagesPerTask` | integer | `20` | How deep to go per market (safety ceiling) |
| `enrichListings` | boolean | `true` | **Lead details** — collect the full profile for every business, contact details included when published |
| **📍 Place Details** | | | |
| `enablePlaceDetails` | boolean | `false` | Enrich specific business links |
| `placeUrls` | string\[] | — | Tripadvisor business links |
| **⭐ Reviews** | | | |
| `enableReviews` | boolean | `false` | Collect reviews for specific links |
| `reviewUrls` | string\[] | — | Tripadvisor business links |
| `maxReviewsPerPlace` | integer | `30` | Max reviews per business |
| **⚙️ Output & limits** | | | |
| `maxItems` | integer | `1000` | Global cap on dataset rows across all features |
| `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 business or review 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": [{ "category": "restaurant", "location": "Austin", "maxItems": 50 }],
  "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
  "webhookFormat": "slack"
}
```

**Example — lead export with JSON webhook**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [{ "category": "restaurant", "location": "Chicago" }],
  "enrichListings": true,
  "webhookUrl": "https://your-crm.example.com/api/leads",
  "webhookFormat": "json"
}
```

***

### Quick start examples

**Multi-market restaurant leads**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [
    { "category": "restaurant", "location": "Austin", "maxItems": 100 },
    { "category": "restaurant", "location": "Dallas", "maxItems": 100 }
  ],
  "enrichListings": true
}
```

**Hotels across destinations**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [
    { "category": "hotel", "location": "Las Vegas", "maxItems": 50 },
    { "category": "hotel", "location": "Miami", "maxItems": 50 }
  ],
  "enrichListings": true
}
```

**Attractions by geo ID (any market)**

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [{ "category": "attraction", "location": "298184", "maxItems": 75 }]
}
```

**Enrich a link list**

```json
{
  "enableListingDiscovery": false,
  "enablePlaceDetails": true,
  "placeUrls": [
    "https://www.tripadvisor.com/Restaurant_Review-g60763-d7890999-Reviews-Kuu_Ramen-New_York_City_New_York.html"
  ]
}
```

**Review sentiment feed**

```json
{
  "enableListingDiscovery": false,
  "enableReviews": true,
  "reviewUrls": [
    "https://www.tripadvisor.com/Restaurant_Review-g60763-d7890999-Reviews-Kuu_Ramen-New_York_City_New_York.html"
  ],
  "maxReviewsPerPlace": 100
}
```

**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": [
      { "category": "restaurant", "location": "New York", "maxItems": 100 },
      { "category": "hotel", "location": "London", "maxItems": 100 }
    ],
    "enrichListings": true
  }'
```

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 features 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 business for an LLM prompt

```json
{
  "featureType": "listing",
  "name": "Kuu Ramen",
  "category": "restaurant",
  "address": "20 John St, New York City, New York, 10038, US",
  "telephone": "+1 212-571-7177",
  "emails": ["contact@example.com"],
  "rating": 4.6,
  "reviewCount": 308,
  "priceRange": "$",
  "cuisine": ["Japanese", "Asian", "Soups"],
  "url": "https://www.tripadvisor.com/Restaurant_Review-g60763-d7890999-Reviews-Kuu_Ramen-New_York_City_New_York.html",
  "marketLabel": "Restaurants | New York"
}
```

#### 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 (enrich → score → outreach).

```
User: "Find highly rated restaurants in Austin with phone numbers and summarize each for outreach"
→ MCP runs the Actor with listingTasks=[{category:"restaurant", location:"Austin"}], enrichListings=true
→ MCP reads dataset items
→ LLM summarizes and drafts emails
```

***

### Connection & performance

- Apify's built-in residential proxy (US) is enabled by default — no extra setup.
- Default memory is **512 MB**, enough headroom for large runs. Increase memory for very large multi-market jobs.
- Records are delivered to the dataset as they arrive, so long runs do not accumulate data in memory.
- A business that cannot be loaded is skipped, so one bad record never stops the run.

***

### 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`), so the upgrade path is visible without any guesswork.

***

### Limitations & compliance

- Data is limited to what Tripadvisor publicly displays for each business.
- Contact emails are returned only when a business publicly exposes one; not every business has an email.
- Some markets may return fewer businesses than requested.
- Not affiliated with, endorsed by, or sponsored by Tripadvisor. Use responsibly and comply with applicable laws and Tripadvisor's Terms of Service. Always respect rate limits and local regulations when collecting business data.

***

### FAQ

**I got fewer results than `maxItems`.**
`maxItems` is a ceiling. Each market also has its own `maxItems` and `maxPagesPerTask` cap, and some markets list fewer businesses. Filtering to only businesses that have a phone, email or website happens on your side after the run — every business is always included in the dataset.

**Why is a business missing an email?**
Emails are only returned when the business publicly publishes one. Keep **Lead details** on (`enrichListings: true`) for the best chance.

**Can I collect from a city that isn't in the common list?**
Yes — use its numeric Tripadvisor geo ID, or paste the market's Tripadvisor link. Common city names are supported out of the box.

**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.

***

### 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)
- Tripadvisor / hospitality / local lead-gen data projects at scale
- LLM & MCP integrations with your data stack
- Web apps, dashboards and automation tools

***

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

# Actor input Schema

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

Discover restaurants, hotels and attractions by market. Enabled by default.

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

One row per category + market. Location accepts a common city name (e.g. "New York", "London"), a numeric Tripadvisor geo ID, or a full Tripadvisor market link.

## `maxPagesPerTask` (type: `integer`):

How deep to go per market, as a safety ceiling for very large runs.

## `enrichListings` (type: `boolean`):

Collect the full profile for every business found — address details, coordinates, rating, description and contact details (phone, website, email where the business has one). Every business is always included; a field stays empty when a business does not have that detail. Turn off for a faster, lighter run with business names and links only.

## `enablePlaceDetails` (type: `boolean`):

Extract a complete structured profile for specific Tripadvisor business links.

## `placeUrls` (type: `array`):

Tripadvisor restaurant, hotel or attraction links.

## `enableReviews` (type: `boolean`):

Extract reviews (author, rating, date, trip type, text) from specific Tripadvisor business links.

## `reviewUrls` (type: `array`):

Tripadvisor business links to collect reviews from.

## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews to collect from each URL.

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

Global cap on dataset rows for this run across all features. 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 Tripadvisor collection.

## Actor input object example

```json
{
  "enableListingDiscovery": true,
  "listingTasks": [
    {
      "category": "restaurant",
      "location": "New York",
      "maxItems": 50
    },
    {
      "category": "hotel",
      "location": "Las Vegas",
      "maxItems": 30
    }
  ],
  "maxPagesPerTask": 20,
  "enrichListings": true,
  "enablePlaceDetails": false,
  "placeUrls": [],
  "enableReviews": false,
  "reviewUrls": [],
  "maxReviewsPerPlace": 30,
  "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.

## `businesses` (type: `string`):

Restaurants, hotels and attractions from discovery and place details.

## `reviews` (type: `string`):

Review rows linked to each business.

## `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": [
        {
            "category": "restaurant",
            "location": "New York",
            "maxItems": 50
        },
        {
            "category": "hotel",
            "location": "Las Vegas",
            "maxItems": 30
        }
    ],
    "maxPagesPerTask": 20,
    "enrichListings": true,
    "maxReviewsPerPlace": 30,
    "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/tripadvisor-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": [
        {
            "category": "restaurant",
            "location": "New York",
            "maxItems": 50,
        },
        {
            "category": "hotel",
            "location": "Las Vegas",
            "maxItems": 30,
        },
    ],
    "maxPagesPerTask": 20,
    "enrichListings": True,
    "maxReviewsPerPlace": 30,
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/tripadvisor-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": [
    {
      "category": "restaurant",
      "location": "New York",
      "maxItems": 50
    },
    {
      "category": "hotel",
      "location": "Las Vegas",
      "maxItems": 30
    }
  ],
  "maxPagesPerTask": 20,
  "enrichListings": true,
  "maxReviewsPerPlace": 30,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/tripadvisor-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/tripadvisor-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/IKQDTvZ71HJVvecJh/builds/f4o7p2dex9AlB4E2M/openapi.json