# OpenTable Real-Time Data (`b2b_leads/opentable-real-time-data`) Actor

Get real-time OpenTable restaurant data for any city or cuisine: profiles, ratings, reviews, reservations, prices, contact details, websites, emails and socials. Perfect for lead generation, market research and AI workflows. Every result streams instantly to your dataset or webhook.

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

## OpenTable Real-Time Data

**Turn OpenTable into a clean, structured restaurant database.** Discover restaurants across any city and cuisine, pull full restaurant profiles, capture ratings, price bands, reservation volume, photos and coordinates, and enrich every listing with the restaurant's own website and contact email — all as **clean, structured JSON streamed to your Apify dataset in real time.**

Built for lead-gen agencies, restaurant-tech companies, market researchers, sales teams and AI workflows that need **reliable OpenTable data without slow, high-maintenance tooling.**

> 💡 **Free plan / paid plan.** This Actor is built for **paid Apify plans**. Free (non-paying) Apify accounts run in a **restricted mode and receive only a small sample (2 results)** — upgrade to a **paid Apify plan** to unlock full, unlimited output. The restriction is intentional (not a bug) and is repeated on the relevant input fields below.

***

### Why this Actor

| | OpenTable Real-Time Data | Typical OpenTable setup |
|---|--------------------------|--------------------------|
| **Speed** | Fast collection, many markets at once | Often 5–20 s per restaurant |
| **Memory** | **1024 MB** default — light, streaming output | 2–4 GB+, data accumulates in memory |
| **Reliability** | Managed Apify residential proxy + automatic recovery from temporary hiccups | Breaks on the first hiccup |
| **Setup** | Clean, organized input UI — run in seconds | Fragile scripts you maintain yourself |
| **Output** | One flat, LLM-ready JSON row per restaurant | Messy markup that still needs cleaning |
| **Multi-market** | Many keyword + market pairs per run | Usually one query at a time |
| **Contact enrichment** | Website **and** email discovery built in | Rarely included |
| **Delivery** | Dataset streaming **+ optional real-time webhook** | Dataset only |

***

### What you get — 30+ data points per restaurant

Every row is tagged with `featureType` and `scrapedAt` so you can filter, join and pipe it into any workflow.

| Group | Fields |
|-------|--------|
| **Identity** | `restaurantId`, `name`, `url`, `type`, `diningStyle`, `description` |
| **Location** | `addressLine1`, `addressLine2`, `city`, `state`, `postCode`, `country`, `neighborhood`, `latitude`, `longitude` |
| **Pricing** | `priceBandId`, `priceBandName`, `priceRange` (`$`–`$$$$`), `currencySymbol` |
| **Reputation** | `rating`, `reviewCount`, `reservationCount`, `topReviewText` |
| **Food & venue** | `primaryCuisine`, `cuisine[]`, `hasBar`, `hasCounter`, `hasHighTop`, `hasOutdoor`, `hasPrivateDining`, `hasEnhancedPrivateDining`, `hasTakeout`, `maxPartySize` |
| **Media & badges** | `photoUrl`, `imageUrls[]`, `awards[]` |
| **Contact** | `phoneNumber`, `formattedPhoneNumber`, `website`, `websites[]`, `email`, `emails[]`, `socials[]` |
| **Booking & ordering** | `offers[]`, `deliveryPartners[]`, `orderOnlineUrl` |
| **Traceability** | `marketLabel`, `searchKeyword`, `searchIndex`, `sourceUrl`, `featureType`, `scrapedAt` |

***

### Features

#### 🍽️ Restaurant Discovery — on by default

Discover restaurants by **keyword + market**. Add as many rows as you like — e.g. *sushi in New York* and *italian in Chicago* — and they all run in a single job.

- Search by cuisine, dish, restaurant name or dining style.
- Target any city or area — dozens of major markets are recognized out of the box, and any other city still works.
- Optional **party size**, **date & time** and **price band** filters.
- Control results per task and collection depth for very large runs.
- Every row streams to the dataset as it is collected — memory stays flat on long runs.

#### 📍 Restaurant Details

Already have OpenTable restaurant URLs or numeric restaurant IDs? Paste them to receive a **complete structured profile** — name, description, dining style, full address, neighborhood, coordinates, price band, rating, review and reservation counts, cuisines, venue features, photos, phone, website, offers, delivery partners and online ordering.

#### 🎯 Lead details

Enable **Lead details** to enrich every result with the restaurant's own website, contact email(s) and social profiles (Instagram, Facebook, TikTok, X, YouTube) — the switch that turns a bare listing into an actionable lead.

Results are **never filtered out**: every restaurant you asked for lands in the dataset, and contact fields are simply left empty when a business does not publish them. That means a run of 1,000 returns exactly 1,000 rows — predictable for pricing, budgets and downstream pipelines. Need only rows with emails? Filter the dataset afterward on the `email` field (or use the built-in **Leads** dataset view), or pipe the webhook into your CRM and filter there.

#### 🔔 Webhooks (real-time delivery)

Every record is **always written to the Apify dataset first**. If you set a **Webhook URL**, each new record is **also POSTed in real time** to your CRM, Slack, Zapier, Make, Google Sheets or custom destination. Choose JSON (full record) or a Slack-friendly message. Delivery is best-effort — a failed webhook never stops the run.

#### 💳 Billing

Billed per result via Apify pay-per-event. Runs respect your **maximum cost per run** and finish gracefully at the limit.

***

### Use cases

- **Restaurant lead generation** — build outreach lists with phone, website and email for any city or cuisine.
- **Multi-city prospecting** — run dozens of keyword + market pairs in one job.
- **Market mapping & density** — compare how many restaurants, and at what price bands, exist per neighborhood.
- **Competitive intelligence** — track ratings, review counts and reservation volume across competitors.
- **Cuisine gap analysis** — find under-served cuisines and neighborhoods for expansion.
- **Sales prospecting for restaurant-tech** — POS, reservations, marketing, delivery and supply vendors.
- **Price positioning studies** — benchmark price bands by market and cuisine.
- **Reputation monitoring** — watch rating and review-count movement for a portfolio.
- **Data enrichment** — start from a URL or ID list and backfill full structured profiles.
- **AI & LLM pipelines** — JSON for RAG, scoring, outreach drafts and territory summaries.
- **CRM & warehouse feeds** — stream to your systems via webhook or the Apify API.
- **Franchise & expansion research** — size demand for a concept in a new metro or neighborhood.
- **Supplier prospecting** — find restaurants by cuisine, price band and location for B2B outreach.

***

### Input reference

Enable only what you need. All features are independent.

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| **Restaurant Discovery** | | | |
| `enableSearch` | boolean | `true` | Discover restaurants by keyword + market |
| `searchTasks` | object\[] | 2 example rows | Primary input: `{ keyword, location, maxItems?, partySize?, dateTime?, priceBands? }` per row |
| `maxDepthPerTask` | integer | `20` | Collection-depth safety ceiling per market |
| **Restaurant Details** | | | |
| `enableRestaurantDetails` | boolean | `false` | Extract full profiles for specific URLs / IDs |
| `restaurantUrls` | string\[] | — | OpenTable restaurant URLs |
| `restaurantIds` | string\[] | — | Numeric OpenTable restaurant IDs |
| **Lead details** | | | |
| `enrichContacts` | boolean | `false` | Add website, email(s) and social profiles to every restaurant. Results are never filtered — all rows are always returned |
| **Output & limits** | | | |
| `maxItems` | integer | `1000` | Global cap on dataset rows for the run (set higher for large runs) |
| `webhookUrl` | string | — | Optional real-time POST URL — dataset is always written; webhook is additional |
| `webhookFormat` | enum | `json` | `json` (full record) or `slack` (Slack message) |
| **Connection** | | | |
| `proxyConfiguration` | object | Apify residential | Apify proxy settings (on by default) |

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

***

### Output reference

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

| `featureType` | Description |
|---------------|-------------|
| `search` | Restaurant from keyword discovery |
| `restaurant_details` | Full profile from a restaurant URL or ID |

**Traceability fields on discovery results:**

- `marketLabel` — e.g. `"sushi | New York, NY"`
- `searchKeyword` — the keyword that produced this row
- `searchIndex` — 1-based position within the market

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

#### Example record

```json
{
  "featureType": "search",
  "restaurantId": 1197892,
  "name": "Bad Habits",
  "url": "https://www.opentable.com/r/bad-habits-astoria",
  "description": "A lively neighborhood spot with a modern menu.",
  "diningStyle": "Casual Dining",
  "addressLine1": "32-03 Broadway",
  "city": "Astoria",
  "state": "NY",
  "postCode": "11106",
  "neighborhood": "Astoria",
  "latitude": 40.7616752,
  "longitude": -73.9242925,
  "priceBandId": 2,
  "priceBandName": "$$",
  "priceRange": "$$",
  "currencySymbol": "$",
  "rating": 4.5,
  "reviewCount": 171,
  "reservationCount": 1,
  "primaryCuisine": "Modern American",
  "cuisine": ["Modern American", "Sushi", "Fusion"],
  "hasBar": true,
  "hasOutdoor": true,
  "maxPartySize": 8,
  "photoUrl": "https://resizer.otstatic.com/v3/photos/54327307-3?width=320&height=320",
  "phoneNumber": "+13477385989",
  "formattedPhoneNumber": "(347) 738-5989",
  "website": "https://www.badhabitsastoria.com/",
  "email": "info@example.com",
  "emails": ["info@example.com"],
  "socials": ["https://www.instagram.com/badhabitsastoria"],
  "marketLabel": "sushi | New York, NY",
  "searchKeyword": "sushi",
  "searchIndex": 1,
  "sourceUrl": "https://www.opentable.com/r/bad-habits-astoria",
  "scrapedAt": "2026-09-22T12:00:00.000Z"
}
```

> Note: some text fields (e.g. `description`, `diningStyle`, `primaryCuisine`, `cuisine`, `neighborhood`) are returned **in the language that OpenTable serves for that market's listing**. Restaurant names, ratings, counts, coordinates, phone numbers and URLs are language-neutral.

***

### Webhook delivery (optional)

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

| Setting | Description |
|---------|-------------|
| `webhookUrl` | Your destination URL (http/https). Leave empty to use the dataset only. |
| `webhookFormat` | `json` — full record 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
{
  "enableSearch": true,
  "searchTasks": [{ "keyword": "sushi", "location": "New York, NY", "maxItems": 10 }],
  "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
  "webhookFormat": "slack"
}
```

**Example — leads with emails + JSON webhook**

```json
{
  "enableSearch": true,
  "searchTasks": [{ "keyword": "italian", "location": "Chicago, IL", "maxItems": 100 }],
  "enrichContacts": true,
  "webhookUrl": "https://your-crm.example.com/api/leads",
  "webhookFormat": "json"
}
```

***

### Quick start examples

**Multi-market lead gen (default pattern)**

```json
{
  "enableSearch": true,
  "searchTasks": [
    { "keyword": "sushi", "location": "New York, NY", "maxItems": 100 },
    { "keyword": "sushi", "location": "Los Angeles, CA", "maxItems": 100 }
  ],
  "enrichContacts": true
}
```

**High-end dining prospecting**

```json
{
  "enableSearch": true,
  "searchTasks": [
    { "keyword": "steakhouse", "location": "Miami, FL", "maxItems": 60, "priceBands": ["3", "4"] }
  ],
  "enrichContacts": true
}
```

**Enrich a URL / ID list**

```json
{
  "enableSearch": false,
  "enableRestaurantDetails": true,
  "restaurantUrls": ["https://www.opentable.com/r/bad-habits-astoria"],
  "restaurantIds": ["1197892"],
  "enrichContacts": true
}
```

**Dinner availability context (party of 4, Friday)**

```json
{
  "enableSearch": true,
  "searchTasks": [
    { "keyword": "brunch", "location": "Austin, TX", "maxItems": 40, "partySize": 4, "dateTime": "2026-10-02T19:00" }
  ]
}
```

***

### 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. Pull 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.

#### Apify MCP (Model Context Protocol)

Use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants can:

- **Run** this Actor with natural-language instructions
- **Read** dataset results directly in the chat
- **Chain** it with other Actors (enrich → score → CRM)

```
User: "Find 30 highly rated Italian restaurants in Chicago with emails and summarize each for outreach"
→ MCP runs the Actor with searchTasks=[{ keyword: "italian", location: "Chicago, IL" }], enrichContacts=true
→ MCP reads dataset items
→ LLM summarizes and drafts emails
```

#### 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 '{
    "enableSearch": true,
    "searchTasks": [
      { "keyword": "sushi", "location": "New York, NY", "maxItems": 10 },
      { "keyword": "italian", "location": "Chicago, IL", "maxItems": 10 }
    ],
    "enrichContacts": true
  }'
```

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

***

### Proxy & performance

- **Apify residential proxy is enabled by default** — no extra setup required on Apify.
- Default memory: **1024 MB**.
- Results are **streamed to the dataset as they are collected**, so long runs never pile up data in memory.
- Discovery and details both collect deeply and **deduplicate restaurants automatically** within a market.

***

### FAQ

**How many restaurants can I get in one run?**
There is no hard limit — set `maxItems` high (e.g. 5,000+) and add as many keyword + market rows as you need.

**Can I run many cities in one job?**
Yes. Each `searchTasks` row is an independent keyword + market, and they all run in the same job.

**Do I get emails for outreach?**
Enable **Lead details**. When a restaurant publishes contact details, `website`, `email`, `emails[]` and `socials[]` are filled in.

**Can I get only rows that have emails / websites / high ratings?**
The Actor always returns every row it collects so run size stays predictable — filter afterward on the `email`, `website` or `rating` fields (export the built-in **Leads** dataset view, or filter in your CRM/Sheet). That keeps pricing and budgets tied to the exact number of rows you request.

**Can I enrich a list I already have?**
Yes. Use **Restaurant Details** with your OpenTable URLs or numeric restaurant IDs.

**Can I get results in my own systems in real time?**
Yes. Set a **Webhook URL** and choose JSON or Slack formatting.

**Which format is the output?**
One flat JSON object per restaurant, plus CSV, Excel and RSS export options.

**Are there fields that may be empty?**
Some fields depend on what OpenTable lists for a given restaurant (for example, not every restaurant publishes an email). Empty fields are returned as `null` or `[]`, never guessed.

***

### Limitations & compliance

- Field availability depends on what OpenTable lists for a given restaurant.
- Some localized fields are returned in the language served for that market's listing.
- Contact discovery is best-effort — not every restaurant publishes an email.
- Not affiliated with OpenTable. Use responsibly and comply with applicable laws and OpenTable's Terms of Service.
- Always respect rate limits and local regulations when collecting business data.

***

### Contact & custom work

Need something beyond this Actor? I build **custom data products**, **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)
- Restaurant / local-market / lead-gen data projects at scale
- LLM & MCP integrations with your data stack
- Web apps, dashboards and automation tools

***

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

# Actor input Schema

## `enableSearch` (type: `boolean`):

Discover restaurants by keyword and market. Enabled by default.

## `searchTasks` (type: `array`):

One row per keyword + market. Location accepts a city or area name (e.g. "New York, NY", "London", "Toronto").

## `maxDepthPerTask` (type: `integer`):

Safety ceiling on how deep each market is collected for very large runs. NOTE: on the Apify free plan this Actor returns only a small free sample (2 results) — upgrade to a paid Apify plan for full, unlimited output.

## `enableRestaurantDetails` (type: `boolean`):

Extract a complete structured profile for specific OpenTable restaurant URLs or restaurant IDs.

## `restaurantUrls` (type: `array`):

OpenTable restaurant URLs (e.g. https://www.opentable.com/r/restaurant-name-city).

## `restaurantIds` (type: `array`):

Numeric OpenTable restaurant IDs.

## `enrichContacts` (type: `boolean`):

Adds each restaurant's website, contact email(s) and social profiles when available. Every restaurant is always included in the results — fields are simply left empty when a business does not publish them.

## `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 returns a small free sample (2 results) — upgrade to a paid Apify plan for full, unlimited output.

## `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). Full output requires a paid Apify plan.

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

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

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

Apify residential proxy is enabled by default for reliable OpenTable collection. No setup needed.

## Actor input object example

```json
{
  "enableSearch": true,
  "searchTasks": [
    {
      "keyword": "sushi",
      "location": "New York, NY",
      "maxItems": 10
    },
    {
      "keyword": "italian",
      "location": "Chicago, IL",
      "maxItems": 10
    }
  ],
  "maxDepthPerTask": 20,
  "enableRestaurantDetails": false,
  "restaurantUrls": [],
  "restaurantIds": [],
  "enrichContacts": false,
  "maxItems": 1000,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

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

## `restaurants` (type: `string`):

All restaurants with the core profile fields.

## `leads` (type: `string`):

Contact-focused view of every collected restaurant (phone, website, email).

## `details` (type: `string`):

Full profiles from restaurant detail lookups.

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

Per-run metadata: record counts by feature, markets, 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 = {
    "enableSearch": true,
    "searchTasks": [
        {
            "keyword": "sushi",
            "location": "New York, NY",
            "maxItems": 10
        },
        {
            "keyword": "italian",
            "location": "Chicago, IL",
            "maxItems": 10
        }
    ],
    "maxDepthPerTask": 20,
    "enrichContacts": false,
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/opentable-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 = {
    "enableSearch": True,
    "searchTasks": [
        {
            "keyword": "sushi",
            "location": "New York, NY",
            "maxItems": 10,
        },
        {
            "keyword": "italian",
            "location": "Chicago, IL",
            "maxItems": 10,
        },
    ],
    "maxDepthPerTask": 20,
    "enrichContacts": False,
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/opentable-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 '{
  "enableSearch": true,
  "searchTasks": [
    {
      "keyword": "sushi",
      "location": "New York, NY",
      "maxItems": 10
    },
    {
      "keyword": "italian",
      "location": "Chicago, IL",
      "maxItems": 10
    }
  ],
  "maxDepthPerTask": 20,
  "enrichContacts": false,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call b2b_leads/opentable-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/opentable-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/l5J5XOmd63zhJAZBV/builds/OrPRrtGrigkhtYbfH/openapi.json