# Airbnb Experiences Scraper (`automation-lab/airbnb-experiences-scraper`) Actor

Extract public Airbnb Experiences by destination or URL, including titles, descriptions, ratings, review counts, images, locations, and scheduled start dates. Export to JSON, CSV, Excel, or API with no Airbnb login required.

- **URL**: https://apify.com/automation-lab/airbnb-experiences-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Airbnb Experiences Scraper

Collect public **Airbnb Experiences** catalogs and detail records by destination or URL.
Export experience IDs, titles, descriptions, ratings, review counts, images, locations, and public scheduled start dates to JSON, CSV, Excel, XML, or RSS.
No Airbnb login or private API key is required.

Use a destination such as `Los Angeles, CA`, paste an Airbnb Experiences URL, choose a result limit, and start the Actor.
The HTTP-first extractor reads server-rendered cards and Product/Event structured data without running a costly browser by default.

### What does Airbnb Experiences Scraper do?

Airbnb Experiences Scraper turns public destination catalogs and experience pages into reusable structured data.
It supports two practical workflows:

- 🔎 Discover experience inventory for one or more travel destinations.
- 🔗 Extract a known experience directly from its `/experiences/{id}` URL.
- ⭐ Track ratings and review-count changes over scheduled runs.
- 🗺️ Capture public place and address fields exposed on detail pages.
- 📅 Save the next public scheduled start date when Airbnb includes Event JSON-LD.
- 🖼️ Collect source image URLs for catalog analysis.

Version 1 only returns fields independently observed in public server-rendered HTML.
It does not promise price, availability, host profiles, or review text.
This conservative contract helps prevent misleading empty columns when Airbnb changes what it exposes publicly.

### Who is it for?

**Tour and activity operators**

- Compare destination catalogs with nearby or competing experiences.
- Refresh ratings, review counts, descriptions, and imagery on a schedule.
- Discover new activity concepts entering a market.

**Online travel agencies and inventory teams**

- Build destination-level activity indexes for internal research.
- Normalize public experience records before human supplier review.
- Feed new URLs into catalog-monitoring pipelines.

**Travel market analysts**

- Compare activity density between cities.
- Study rating and review-count distributions.
- Track how public descriptions and scheduled dates change over time.

**Developers and data teams**

- Replace manual browsing with a repeatable API call.
- Export data into a warehouse, spreadsheet, or dashboard.
- Trigger downstream workflows with webhooks after each run.

### Why use this Airbnb Experiences extractor?

- ✅ **No Airbnb account required** for the documented public-data scope.
- ⚡ **HTTP-first extraction** avoids browser startup and keeps runs lightweight.
- 🎯 **Two input routes** support discovery and direct entity lookup.
- 🧹 **Global deduplication** prevents duplicate experience IDs across inputs.
- 🛡️ **Fail-closed URL validation** rejects Airbnb stays and unrelated routes.
- 🔁 **Bounded retries** handle temporary delivery failures without endless loops.
- 📦 **Ready exports** include JSON, CSV, Excel, XML, and RSS.
- ⏰ **Apify schedules** make recurring catalog refreshes simple.
- 🔌 **API and integrations** connect results to existing tools.
- 💳 **Pay per event** means charges follow emitted experience records.

### What Airbnb Experiences data can you extract?

| Category | Field | Description |
|---|---|---|
| Identity | `experienceId` | Stable numeric ID parsed from the Airbnb URL |
| Identity | `title` | Public experience name |
| Content | `description` | Card summary or detail-page description |
| Reputation | `rating` | Numeric average rating when exposed |
| Reputation | `reviewCount` | Public aggregate rating count |
| Media | `images` | Deduplicated public image URL array |
| Place | `locationName` | Public Event place label |
| Place | `city` | Address locality |
| Place | `region` | Address region or state |
| Place | `country` | Address country |
| Schedule | `startDates` | Public Event start dates found during the run |
| Links | `experienceUrl` | Canonical Airbnb experience URL |
| Links | `discoveryUrl` | Destination page where the record was found |
| Lineage | `sourceType` | `destination` or `direct` |
| Lineage | `scrapedAt` | ISO timestamp for the extraction |

Optional fields are omitted when Airbnb does not expose them.
The Actor does not replace missing values with invented defaults.

### How much does it cost to scrape Airbnb Experiences?

This Actor uses **pay-per-event pricing**.
There is a small run-start charge and one charge for each unique experience saved.
All Apify platform usage is included in the displayed event price.

| Event | Free | Starter / Bronze | Scale / Silver | Business / Gold |
|---|---:|---:|---:|---:|
| Run started | $0.005 | $0.005 | $0.005 | $0.005 |
| One experience | $0.00051385 | $0.00044682 | $0.00034852 | $0.00026809 |

Higher enterprise tiers receive additional volume discounts.
Prices were derived from a representative 10-record cloud run and verified against the live Actor configuration.

**Example estimates at current prices**

| Workflow | Records | Approximate Free-tier charge |
|---|---:|---:|
| One direct experience lookup | 1 | $0.00551 |
| Small destination sample | 10 | $0.01014 |
| Multi-destination catalog | 100 | $0.05639 |

The final run can return fewer records than the limit when the public source contains fewer unique experiences.

### How to scrape Airbnb Experiences

1. Open [Airbnb Experiences Scraper](https://apify.com/automation-lab/airbnb-experiences-scraper).
2. Enter one or more destination names under **Destination searches**.
3. Optionally add destination or direct experience URLs.
4. Set **Maximum experiences** to a small number for the first run.
5. Leave **Fetch experience details** enabled when you need locations and scheduled dates.
6. Click **Start**.
7. Preview records in the Dataset tab.
8. Export the dataset or connect it to your application.

**Quick destination input**

```json
{
  "searchQueries": ["Los Angeles, CA"],
  "maxItems": 10,
  "enrichDetails": true
}
````

**Direct experience input**

```json
{
  "startUrls": [
    { "url": "https://www.airbnb.com/experiences/6101449" }
  ],
  "maxItems": 1,
  "enrichDetails": true
}
```

**Multi-destination monitoring input**

```json
{
  "searchQueries": ["Los Angeles, CA", "New York, NY", "Paris, France"],
  "maxItems": 100,
  "enrichDetails": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | string array | none | City and region names converted to public Airbnb destination routes |
| `startUrls` | request list | none | Destination, `/s/.../experiences`, or direct experience URLs |
| `maxItems` | integer | `10` | Global unique experience limit from 1 to 1,000 |
| `enrichDetails` | boolean | `true` | Fetch Product/Event JSON-LD from detail pages |
| `proxyConfiguration` | object | direct connection | Optional Apify Proxy or custom proxies |

Provide at least one destination query or URL.
When both are present, the Actor processes them in order and deduplicates by experience ID.
Only public HTTPS Airbnb Experiences routes are accepted.

### Output example

```json
{
  "experienceId": "6101449",
  "title": "Pickle tasting adventure with the Pickleman",
  "description": "Meet the Pickleman at his pickle tasting bar in the Original Farmers Market.",
  "rating": 5,
  "reviewCount": 71,
  "images": [
    "https://a0.muscache.com/im/pictures/Mt/MtTemplate-6101449/original/example.jpeg"
  ],
  "locationName": "Los Angeles, CA",
  "city": "Los Angeles",
  "region": "CA",
  "country": "United States",
  "startDates": ["2026-07-16T18:30:00.000Z"],
  "experienceUrl": "https://www.airbnb.com/experiences/6101449",
  "sourceType": "direct",
  "scrapedAt": "2026-07-16T05:02:53.719Z"
}
```

Destination rows also include `discoveryUrl`.
Dates represent only public Event structured data observed during that run, not a complete availability calendar.

### Tips for reliable results

- Start with 5–10 records to validate your destination and output shape.
- Keep detail enrichment on when location and schedule fields matter.
- Turn detail enrichment off for a fast catalog-title and image sample.
- Use explicit Airbnb destination URLs when a destination name is ambiguous.
- Schedule runs at a respectful cadence instead of repeatedly scraping the same page.
- Configure a proxy only if direct delivery is rate-limited or geography-dependent.
- Compare records by `experienceId`, not title, because titles can change.
- Treat `startDates` as a point-in-time public signal rather than guaranteed availability.

### Monitor Airbnb Experiences on a schedule

Apify schedules can rerun the same destination input hourly, daily, weekly, or with a custom cron expression.
A typical monitoring workflow is:

1. Run the Actor daily with stable destination queries.
2. Export records to a named warehouse table or spreadsheet.
3. Upsert by `experienceId`.
4. Compare `rating`, `reviewCount`, `description`, and `startDates` with the previous snapshot.
5. Notify an analyst only when a meaningful field changes.

Keep historical snapshots outside the default dataset if longitudinal analysis is required.

### Integrations for travel-data workflows

**Airbnb Experiences → Google Sheets**

Append destination inventory for operator research and manually annotate competitors.

**Airbnb Experiences → Slack or Discord**

Send an alert when a scheduled run discovers an unseen experience ID or rating change.

**Airbnb Experiences → Make or Zapier**

Trigger enrichment, classification, translation, or CRM review after a dataset item is created.

**Airbnb Experiences → Webhook**

Receive a run-finished event and load the dataset into a warehouse or internal travel catalog.

**Airbnb Experiences → Google Drive or S3**

Archive dated CSV or JSON exports for market history and auditability.

### API usage

You can run `automation-lab/airbnb-experiences-scraper` from any HTTP client.
Replace `APIFY_TOKEN` with a token from your Apify account.

**Node.js**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/airbnb-experiences-scraper').call({
    searchQueries: ['Los Angeles, CA'],
    maxItems: 10,
    enrichDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/airbnb-experiences-scraper').call(run_input={
    'searchQueries': ['Los Angeles, CA'],
    'maxItems': 10,
    'enrichDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~airbnb-experiences-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["Los Angeles, CA"],"maxItems":10,"enrichDetails":true}'
```

### Use with AI agents via MCP

Use the hosted [Apify MCP server](https://mcp.apify.com?tools=automation-lab/airbnb-experiences-scraper) to call this Actor from compatible AI assistants.

**Claude Code**

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/airbnb-experiences-scraper"
```

**Claude Desktop, Cursor, or VS Code**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/airbnb-experiences-scraper"
    }
  }
}
```

Your client uses OAuth to connect to your Apify account.
Try these example prompts:

- “Use `automation-lab/airbnb-experiences-scraper` to collect 20 Los Angeles experiences with detail fields.”
- “Extract this Airbnb Experience URL and summarize its location, rating, and next public start date.”
- “Compare public Airbnb Experience catalogs in New York and Paris by rating and review count.”

### Data quality and limitations

Airbnb controls the source markup and can change it without notice.
The Actor uses public SSR HTML and Product/Event JSON-LD, plus bounded retries for transient variants.

- Destination pages may expose different catalog sizes or layouts by location.
- Some cards omit ratings, review counts, descriptions, or images.
- Some detail pages omit Event location or start-date data.
- `startDates` is not a complete booking calendar.
- Prices, live availability, hosts, and review text are outside the v1 contract.
- Destination results reflect what Airbnb publicly serves at run time.
- A configured proxy can produce geography-specific output.

A run fails non-zero when none of its inputs yields a valid experience record.

### Legality

Scraping public web data is generally permitted in many jurisdictions, but rules depend on the data, location, purpose, and contract.
Use this Actor only for lawful purposes and only collect information you are authorized to process.
Respect Airbnb terms, intellectual-property rights, reasonable request rates, privacy laws, and deletion obligations.
Do not use public records for harassment, discrimination, spam, or attempts to identify private individuals.
When personal data appears, establish a lawful basis and follow applicable GDPR, CCPA, and local requirements.
This guidance is informational and is not legal advice.

### Troubleshooting

**Why did my destination return no experiences?**

Try the exact public Airbnb destination page in `startUrls`.
Destination names can be ambiguous, and Airbnb may not publish an experience catalog for every place.
Inspect the run log for a route-specific warning.

**Why are location or scheduled dates missing?**

Confirm `enrichDetails` is true.
Airbnb does not expose Event JSON-LD on every detail page, so optional fields are omitted when unavailable.

**Why was my URL rejected?**

Only HTTPS Airbnb destination pages, `/s/.../experiences` pages, and direct `/experiences/{id}` URLs are supported.
Airbnb stays, profiles, and unrelated routes intentionally fail closed.

**What should I do after a temporary block?**

Wait before retrying, reduce request frequency, and configure Apify Proxy if direct delivery remains unavailable in your geography.

### FAQ

**How fast is the Airbnb Experiences scraper?**

Catalog-only runs usually require one HTTP request per destination.
Detail-enriched runs add one bounded request per selected experience, so duration grows with `maxItems`.

**How much does one run cost?**

The price is a $0.005 start event plus the tier-specific per-experience event, starting at $0.00051385 per record on the Free tier.
The Actor never charges for more experience events than it emits.

**Does Airbnb provide an official public Experiences API?**

The Actor does not depend on a private or authenticated Airbnb API.
It structures public page data for users who need repeatable exports and automation.

**Does this Actor scrape Airbnb stays?**

No.
Use [Airbnb Scraper](https://apify.com/automation-lab/airbnb-listing) for stay listings.
This Actor focuses only on Airbnb Experiences.

**Can I scrape reviews, hosts, prices, or availability?**

Not in version 1.
Those fields are intentionally excluded until a stable public source is independently verified.

**Can duplicate experiences appear?**

No duplicate IDs are emitted within a run.
Inputs are deduplicated globally by `experienceId`.

### Related travel and Airbnb scrapers

- [Airbnb Scraper](https://apify.com/automation-lab/airbnb-listing) — collect public stay listing data.
- [Airbnb Reviews Scraper](https://apify.com/automation-lab/airbnb-reviews) — extract public review workflows for stays.
- [Booking.com Scraper](https://apify.com/automation-lab/booking-scraper) — collect hotel search and property data.
- [Booking.com Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper) — analyze hotel guest feedback.
- [TripAdvisor Scraper](https://apify.com/automation-lab/tripadvisor-scraper) — collect public travel business data.
- [Google Flights Scraper](https://apify.com/automation-lab/google-flights-scraper) — monitor flight search results.
- [Booking Hotel Photos Scraper](https://apify.com/automation-lab/booking-hotel-photos-scraper) — export hotel image catalogs.
- [US Travel Advisories Scraper](https://apify.com/automation-lab/us-travel-advisories-scraper) — monitor destination risk advisories.

### Responsible operation

Keep initial limits low, avoid unnecessary repeated requests, and schedule only at the freshness interval your workflow needs.
The Actor uses a direct HTTP connection unless proxy settings are supplied.
Every saved row includes source links and a scrape timestamp to support verification and lineage.
If the source returns no valid experience records after bounded retries, the Actor fails rather than reporting a misleading successful empty run.

# Actor input Schema

## `searchQueries` (type: `array`):

Enter city and region names such as Los Angeles, CA or Paris, France.

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

Add Airbnb destination pages ending in /things-to-do, /s/.../experiences search pages, or direct /experiences/{id} URLs.

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

Stop after this many unique Airbnb Experiences across all destinations and URLs.

## `enrichDetails` (type: `boolean`):

Visit each experience page to add full description, location, address, rating, images, and the next public scheduled start date when exposed.

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

Optional Apify Proxy or custom proxy settings.

## Actor input object example

```json
{
  "searchQueries": [
    "Los Angeles, CA"
  ],
  "startUrls": [
    {
      "url": "https://www.airbnb.com/los-angeles-ca/things-to-do"
    },
    {
      "url": "https://www.airbnb.com/experiences/6101449"
    }
  ],
  "maxItems": 5,
  "enrichDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "Los Angeles, CA"
    ],
    "startUrls": [
        {
            "url": "https://www.airbnb.com/los-angeles-ca/things-to-do"
        },
        {
            "url": "https://www.airbnb.com/experiences/6101449"
        }
    ],
    "maxItems": 5,
    "enrichDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/airbnb-experiences-scraper").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 = {
    "searchQueries": ["Los Angeles, CA"],
    "startUrls": [
        { "url": "https://www.airbnb.com/los-angeles-ca/things-to-do" },
        { "url": "https://www.airbnb.com/experiences/6101449" },
    ],
    "maxItems": 5,
    "enrichDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/airbnb-experiences-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "Los Angeles, CA"
  ],
  "startUrls": [
    {
      "url": "https://www.airbnb.com/los-angeles-ca/things-to-do"
    },
    {
      "url": "https://www.airbnb.com/experiences/6101449"
    }
  ],
  "maxItems": 5,
  "enrichDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/airbnb-experiences-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/airbnb-experiences-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Experiences Scraper",
        "description": "Extract public Airbnb Experiences by destination or URL, including titles, descriptions, ratings, review counts, images, locations, and scheduled start dates. Export to JSON, CSV, Excel, or API with no Airbnb login required.",
        "version": "0.1",
        "x-build-id": "KDkDJzr6at4TVrDzK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~airbnb-experiences-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-airbnb-experiences-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~airbnb-experiences-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-airbnb-experiences-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~airbnb-experiences-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-airbnb-experiences-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Destination searches",
                        "type": "array",
                        "description": "Enter city and region names such as Los Angeles, CA or Paris, France.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Airbnb Experiences URLs",
                        "type": "array",
                        "description": "Add Airbnb destination pages ending in /things-to-do, /s/.../experiences search pages, or direct /experiences/{id} URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum experiences",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after this many unique Airbnb Experiences across all destinations and URLs.",
                        "default": 10
                    },
                    "enrichDetails": {
                        "title": "Fetch experience details",
                        "type": "boolean",
                        "description": "Visit each experience page to add full description, location, address, rating, images, and the next public scheduled start date when exposed.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```