# Eventbrite Events Scraper: Dates, Venues, Prices & Organizers (`hyperbach/eventbrite-scraper`) Actor

Scrape Eventbrite events by city, keyword, category and date, or by event URL: name, start and end with time zone, venue and address, online flag, organizer, price range or free, ticket availability, category and image. Several places per run, a max per search. No login.

- **URL**: https://apify.com/hyperbach/eventbrite-scraper.md
- **Developed by:** [Hyperbach](https://apify.com/hyperbach) (community)
- **Categories:** Travel, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.25 / 1,000 events

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

## Eventbrite Events Scraper: Dates, Venues, Prices & Organizers

**The events of any place on Eventbrite, logged out: places (with an optional keyword, category and date), Eventbrite discovery URLs or event URLs in, one row per event out — the event's id and URL, name and summary, start and end as local time with the offset and in UTC, the time zone, the online flag, the venue's name, address and coordinates, the organizer's name and page, the price range or free with the currency, ticket availability and sales status, the category, subcategory and format, the organizer's tags and the image URL — several places in one run, a max per search.** One free `search` row per input carries a completeness verdict: COMPLETE (Eventbrite's own end of the list), CAPPED (your limit), TRUNCATED (Eventbrite's own depth limit of 1,000 events a search, with its count) or PARTIAL. No login, no API key, no browser, proxies handled for you.

### Why this Eventbrite scraper

- **Several places in one run.** Give places as Eventbrite spells them (`ny--new-york`, `united-kingdom--london`, `online`) with one keyword, category and date for all of them, or discovery URLs from your browser with the filters you set there, or event URLs. Each search gets its own cap (`maxItemsPerSearch`), and the run's cap sits on top (`maxItems`).
- **The price and the organizer on every row.** Eventbrite's search list shows neither; this actor reads them from Eventbrite's own event data, 20 events a call, at no extra charge: the lowest and highest ticket price with the currency, the free flag, whether tickets are left or sold out, the sales status, and the organizer's name and page.
- **Times you can use.** Start and end as local time with the UTC offset (`2026-10-24T13:00:00-04:00`), the same in UTC, and the IANA time zone (`America/New_York`).
- **Deep searches, checked.** 20 events a page in Eventbrite's own order, page after page, to Eventbrite's own end of the list. Eventbrite lists 1,000 events of a search to a reader (50 pages, measured 2026-10-23) whatever its count says; the free `search` row says so (TRUNCATED, with Eventbrite's count) and names the filter Eventbrite applied. An event a later page or another search repeats is delivered and charged once.
- **Honest runs.** A place Eventbrite does not know and an event id it does not know are free `not_found` rows, each checked twice; a URL that is not Eventbrite's a free `invalid` row. Every input gets a row.

### Who it's for

- **Event marketers and promoters** — what else is on in a city on a date: the competing events, their venues, their ticket prices and whether they are selling out.
- **Event discovery apps and newsletters** — a feed of a city's events by category or keyword, with times in UTC and local time, venues with coordinates and the image, read again every day.
- **Sales and partnership teams** — the organizers of a niche's events in a region (their name and Eventbrite page), and how often and at what price they run events.

### Quick start

**The first 100 events in New York**

```json
{
  "locations": [
    "ny--new-york"
  ],
  "maxItemsPerSearch": 100
}
```

**Jazz this weekend in three cities**

```json
{
  "locations": [
    "ny--new-york",
    "ca--los-angeles",
    "il--chicago"
  ],
  "keyword": "jazz",
  "date": "this-weekend",
  "maxItemsPerSearch": 50
}
```

**A discovery URL with its filters, and two events by URL**

```json
{
  "startUrls": [
    "https://www.eventbrite.com/d/united-kingdom--london/business--events--next-week/",
    "https://www.eventbrite.com/e/new-york-city-wine-fest-tickets-1993626343059"
  ],
  "maxItemsPerSearch": 100
}
```

### Output

One row per event (and one free search row per input):

| field | meaning |
|---|---|
| `row_type` | `event` (one event, charged) or `search` (the input's row with the walk's verdict; free). |
| `input_index` | The 1-based position of the input this row answers: `locations` first, then `startUrls`. |
| `input_value` | The input as you gave it (the place or the URL). |
| `input_kind` | Which input it came from: `location` (`locations`) or `url` (`startUrls`). |
| `search_url` | The search (or the event) on Eventbrite, as a URL you can open. |
| `status` | A search row: `ok`, `not_found`, `invalid`, `duplicate`, `failed` or `not_read` (see the FAQ). An event row: `ok`. |
| `status_detail` | Why a search row is not `ok`, in a sentence. |
| `scraped_at` | When the row was read (ISO 8601, UTC). |
| `position` | The event's place among this search's delivered events (1 = first), in Eventbrite's order. |
| `page` | The discovery page the event was on (20 events a page); null for an event read by URL. |
| `event_id` | Eventbrite's event id (the number at the end of the event URL). |
| `url` | The event's page on Eventbrite. |
| `name` | The event's name. |
| `summary` | The event's short summary, as the organizer wrote it. |
| `start` | When the event starts: local time with the UTC offset (`2026-10-24T13:00:00-04:00`). |
| `end` | When the event ends: local time with the UTC offset. |
| `start_utc` | When the event starts, in UTC (ISO 8601). |
| `end_utc` | When the event ends, in UTC (ISO 8601). |
| `timezone` | The event's time zone (IANA name, `America/New_York`). |
| `is_online` | True for an online event (it then has no venue). |
| `venue_name` | The venue's name. |
| `venue_address` | The venue's address in one line, as Eventbrite shows it. |
| `venue_city` | The venue's city. |
| `venue_region` | The venue's state or region (`NY`). |
| `venue_postal_code` | The venue's postal code. |
| `venue_country` | The venue's country (ISO code, `US`). |
| `latitude` | The venue's latitude. |
| `longitude` | The venue's longitude. |
| `organizer_id` | Eventbrite's id of the organizer's profile. |
| `organizer_name` | The organizer's name, as its Eventbrite page shows it. |
| `organizer_url` | The organizer's page on Eventbrite. |
| `is_free` | True when every ticket is free. |
| `price_min` | The lowest ticket price, in `currency` (0 when a free ticket is among them). |
| `price_max` | The highest ticket price, in `currency`. |
| `currency` | The ticket prices' currency (ISO code, `USD`). |
| `has_available_tickets` | True while tickets are on offer. |
| `is_sold_out` | True when the event is sold out. |
| `sales_status` | Eventbrite's sales status (`on_sale`, `sold_out`, `sales_ended`, `not_yet_on_sale` …). |
| `category` | The event's Eventbrite category (`Music`, `Food & Drink`). |
| `subcategory` | The event's Eventbrite subcategory (`Wine`, `Hip Hop / Rap`). |
| `format` | The event's format (`Festival or Fair`, `Party or Social Gathering`). |
| `tags` | The tags the organizer gave the event. |
| `image_url` | The event's main image, full size. |
| `published_at` | When the event was published on Eventbrite (ISO 8601, UTC). |
| `event_status` | Eventbrite's status of the event (`live`, `started`, `ended`, `canceled` …). |
| `tickets_url` | Eventbrite's checkout link for the event. |
| `details_status` | `served` when the price, availability and organizer fields came with the row; `not_served` when Eventbrite's event data did not answer for this event (those fields are then null). |
| `events_count` | A search row: Eventbrite's own count of events for the search (it caps the figure at 10,000). |
| `events_delivered` | A search row: the event rows this input delivered. |
| `pages_read` | A search row: the discovery pages read. |
| `repeats_skipped` | A search row: events skipped because an earlier page or another input of the run already delivered them. |
| `applied_filters` | A search row: the search Eventbrite says it applied (its words `q`, category `tags`, `dates`, `price`, place ids, online only), as JSON. |
| `verdict` | A search row: `COMPLETE` (Eventbrite's own end of the list), `CAPPED` (your limit), `TRUNCATED` (Eventbrite's limit of 1,000 events a search) or `PARTIAL` (a refusal or the time limit stopped it). |
| `verdict_detail` | A search row: the verdict in a sentence, with the counts. |

Example record:

```json
{
  "row_type": "event",
  "input_index": 1,
  "input_value": "ny--new-york",
  "input_kind": "location",
  "search_url": "https://www.eventbrite.com/d/ny--new-york/all-events/",
  "status": "ok",
  "status_detail": null,
  "scraped_at": "2026-10-23T01:19:13Z",
  "position": 18,
  "page": 1,
  "event_id": "1993626343059",
  "url": "https://www.eventbrite.com/e/new-york-city-wine-fest-tickets-1993626343059",
  "name": "New York City Wine Fest",
  "summary": "Wine Fest is your all access pass to hundreds of new wines from around the world.",
  "start": "2026-10-24T13:00:00-04:00",
  "end": "2026-10-24T16:30:00-04:00",
  "start_utc": "2026-10-24T17:00:00Z",
  "end_utc": "2026-10-24T20:30:00Z",
  "timezone": "America/New_York",
  "is_online": false,
  "venue_name": "Chelsea Industrial",
  "venue_address": "535-549 West 28th Street, New York, NY 10001",
  "venue_city": "New York",
  "venue_region": "NY",
  "venue_postal_code": "10001",
  "venue_country": "US",
  "latitude": 40.7517036,
  "longitude": -74.0036129,
  "organizer_id": "17391741922",
  "organizer_name": "Fest Productions",
  "organizer_url": "https://www.eventbrite.com/o/fest-productions-17391741922",
  "is_free": false,
  "price_min": 18.72,
  "price_max": 80.98,
  "currency": "USD",
  "has_available_tickets": true,
  "is_sold_out": false,
  "sales_status": "on_sale",
  "category": "Food & Drink",
  "subcategory": "Wine",
  "format": "Festival or Fair",
  "tags": [
    "tasting",
    "livemusic",
    "wineries",
    "foodpairings",
    "nycwinefest"
  ],
  "image_url": "https://img.evbuc.com/https%3A%2F%2Fcdn.evbuc.com%2Fimages%2F902183903%2F258699274776%2F1%2Foriginal.20241119-154554?auto=format%2Ccompress&q=75&sharp=10&s=334e0cf1db79e9f655552c5c4afce704",
  "published_at": "2026-07-09T19:38:44Z",
  "event_status": "live",
  "tickets_url": "https://www.eventbrite.com/checkout-external?eid=1993626343059",
  "details_status": "served",
  "events_count": null,
  "events_delivered": null,
  "pages_read": null,
  "repeats_skipped": null,
  "applied_filters": null,
  "verdict": null,
  "verdict_detail": null
}
```

### Pricing

**Pay for the events a run delivers**, plus one run start; no platform usage is billed to you. The event price falls with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Event (`event`) | per 1,000 | $4.50 | $3.825 | $3.15 | $2.25 |
| Run start (`start`) | per run | $0.006 | $0.006 | $0.006 | $0.006 |

An event is **$4.50 per 1,000** on the Free plan ($0.0045 an event), with its price, availability and organizer included. Each run that delivers a charged event also pays the **run start, $0.006 once**; a run that delivers no charged event pays nothing at all. So one place of 100 events costs $0.456 on the Free plan and $0.3885 on Starter, and several places in one run share one start. The free `search` row of every input, a value that is not a place or an Eventbrite URL (`invalid`), a place or event Eventbrite does not know (`not_found`), a repeated input (`duplicate`), an input left at the cap or the time limit (`not_read`) and a refusal the run could not pass (`failed`) are never charged. An event is charged once a run, also when several searches list it. A run that stops early (a timeout, an abort) is charged for the events it delivered. `maxItems` counts the charged rows; before the first request the log names the price of each row at your plan and the most the run can cost. Enterprise plans have their own rates: the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **Places, filters and URLs** — `locations` takes Eventbrite's place slugs: open the place on eventbrite.com and copy the part after `/d/` (`ny--new-york`, `ca--san-francisco`, `united-kingdom--london`, `australia--sydney`, `online`). `keyword`, `category` and `date` apply to every place. `startUrls` takes discovery URLs as your browser shows them (every filter they carry is kept, the free / paid filter too) and event URLs (`/e/…-tickets-<id>`).
- **What a row is** — `row_type` = `event`: one event, in Eventbrite's order (`position`, and the `page` it was on). `row_type` = `search`: the free row of one input value — `events_count` (Eventbrite's own count, which it caps at 10,000), `events_delivered`, `pages_read`, `repeats_skipped`, `applied_filters` (the search Eventbrite says it applied), the `verdict` with its `verdict_detail`, and the `status` with its reason.
- **How far a search goes** — `maxItemsPerSearch` (default 100; 0 = every event the search lists) stops each search after that many new events. Eventbrite lists 1,000 events of a search to a reader (50 pages of 20); a run that reaches that end says TRUNCATED with Eventbrite's count, and a keyword, a category or a date narrows the search to read the rest. `maxItems` caps the charged rows of the whole run.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `locations` | `array` |  | Where to look for events, one place a line, as Eventbrite's own URLs spell it: `ny--new-york`, `ca--los-angeles`, `il--chicago`, `united-kingdom--london`, `canada--toronto`, or `online` for online events (open the place on eventbrite.com and copy the part after `/d/`). Each place is one search, with the keyword, category and date below. A place Eventbrite does not know gets a free `not_found` row; a place given twice a free `duplicate` row. |
| `keyword` | `string` |  | Optional words every place search asks (`jazz`, `startup networking`), as you would type them in Eventbrite's search box. Eventbrite answers words it does not know with related events, not with an empty list. |
| `category` | `business` / `science-and-tech` / `music` / `film-and-media` / `arts` / `fashion` / `health` / `sports-and-fitness` / `travel-and-outdoor` / `food-and-drink` / `charity-and-causes` / `government` / `community` / `spirituality` / `family-and-education` / `holiday` / `home-and-lifestyle` / `auto-boat-and-air` / `hobbies` / `school-activities` / `other` |  | Optional: only events of this Eventbrite category, in every place search. |
| `date` | `today` / `tomorrow` / `this-weekend` / `this-week` / `next-week` / `this-month` / `next-month` |  | Optional: only events on these dates (Eventbrite's own date filter, in each place's time). Empty = every current and future event. |
| `startUrls` | `array` |  | Eventbrite discovery URLs as your browser shows them (`https://www.eventbrite.com/d/ny--new-york/music--events--this-weekend/jazz/`, with every filter you set there kept, the free / paid one too) and event URLs (`https://www.eventbrite.com/e/…-tickets-1990839672051`). An organizer page or a URL of another site gets a free `invalid` row; an event URL Eventbrite does not know a free `not_found` row. |
| `maxItemsPerSearch` | `integer` | `100` | Stop each search (a place or a discovery URL) after this many events (0 = every event the search lists). Eventbrite lists 1,000 events of a search to a reader (50 pages of 20), whatever its own count says; narrow a big city with a keyword, a category or a date. An event met again on a later page, or one another input of the run already delivered, is skipped and not counted. |
| `maxItems` | `integer` | `0` | Stop the run after this many event rows across every search and URL (0 = no limit). Search rows are free and not counted; an input left unread at the cap gets a free `not_read` row. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A URL that is not an Eventbrite discovery or event URL (an organizer page, another site) is not an error: it gets one free `search` row with `status` invalid that says why, and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Which status is which?**

A search row's `status` is `ok` (events served), `not_found` (Eventbrite has no such place, or no such event id; checked on two connections), `invalid` (an empty place, or a URL that is not an Eventbrite discovery or event URL), `duplicate` (the same search or event again in the input: read once; or an event another input already delivered), `failed` (Eventbrite refused every try; free) or `not_read` (left at `maxItems`, the charge limit or the run's time limit). An event row's `status` is `ok`.

**Does it give the full description, the age limit or the refund policy?**

No. The row carries the event's summary and what Eventbrite's search and event data give: times, venue, price range, availability, organizer, category. The full description, the age limit, the refund policy, the performers and the organizer's own description and social links are on each event's own page, which this actor does not read.

**Why does a big city stop at 1,000 events?**

Eventbrite lists 1,000 events of one search to a reader, whatever its count says (page 51 of a search is always empty, measured 2026-10-23). Split a big city with a category, a date or a keyword: each split is its own search with its own 1,000.

**Can it read past events, or an organizer's events?**

No. Eventbrite's discovery pages list current and future events only, and an organizer's page is not read. An event URL of an ended event is read when Eventbrite still serves its data.

**Does it need an Eventbrite account or API key?**

No. Everything is read from Eventbrite's public pages, logged out.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/eventbrite-scraper').call({"locations": ["ny--new-york"], "maxItemsPerSearch": 100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/eventbrite-scraper').call(run_input={'locations': ['ny--new-york'], 'maxItemsPerSearch': 100})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/eventbrite-scraper --input '{"locations": ["ny--new-york"], "maxItemsPerSearch": 100}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~eventbrite-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"locations": ["ny--new-york"], "maxItemsPerSearch": 100}'
```

### Support

apify@hyperbach.com

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

## `locations` (type: `array`):

Where to look for events, one place a line, as Eventbrite's own URLs spell it: `ny--new-york`, `ca--los-angeles`, `il--chicago`, `united-kingdom--london`, `canada--toronto`, or `online` for online events (open the place on eventbrite.com and copy the part after `/d/`). Each place is one search, with the keyword, category and date below. A place Eventbrite does not know gets a free `not_found` row; a place given twice a free `duplicate` row.

## `keyword` (type: `string`):

Optional words every place search asks (`jazz`, `startup networking`), as you would type them in Eventbrite's search box. Eventbrite answers words it does not know with related events, not with an empty list.

## `category` (type: `string`):

Optional: only events of this Eventbrite category, in every place search.

## `date` (type: `string`):

Optional: only events on these dates (Eventbrite's own date filter, in each place's time). Empty = every current and future event.

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

Eventbrite discovery URLs as your browser shows them (`https://www.eventbrite.com/d/ny--new-york/music--events--this-weekend/jazz/`, with every filter you set there kept, the free / paid one too) and event URLs (`https://www.eventbrite.com/e/…-tickets-1990839672051`). An organizer page or a URL of another site gets a free `invalid` row; an event URL Eventbrite does not know a free `not_found` row.

## `maxItemsPerSearch` (type: `integer`):

Stop each search (a place or a discovery URL) after this many events (0 = every event the search lists). Eventbrite lists 1,000 events of a search to a reader (50 pages of 20), whatever its own count says; narrow a big city with a keyword, a category or a date. An event met again on a later page, or one another input of the run already delivered, is skipped and not counted.

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

Stop the run after this many event rows across every search and URL (0 = no limit). Search rows are free and not counted; an input left unread at the cap gets a free `not_read` row.

## Actor input object example

```json
{
  "locations": [
    "ny--new-york"
  ],
  "maxItemsPerSearch": 50,
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped records in the default dataset. One row per event (and one free search row per input):

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

How the run went: event rows charged, events delivered without the price and organizer details, free rows, inputs by status, the walk per search (events delivered, pages read, repeated events skipped, the verdict), the source counters (calls, served, refused, exits, rotations, bytes) and the memory watch.

# 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 = {
    "locations": [
        "ny--new-york"
    ],
    "maxItemsPerSearch": 50,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/eventbrite-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 = {
    "locations": ["ny--new-york"],
    "maxItemsPerSearch": 50,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/eventbrite-scraper").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 '{
  "locations": [
    "ny--new-york"
  ],
  "maxItemsPerSearch": 50,
  "maxItems": 100
}' |
apify call hyperbach/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hyperbach/eventbrite-scraper"
        }
    }
}
```

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/9Jxn3iayfzeMzSaiW/builds/QnowNVhSTgbs5nG6n/openapi.json