# Whova Event Scraper - Sessions, Speakers, Sponsors & Exhibitors (`scrapesage/whova-event-scraper`) Actor

Turn any public Whova event into clean, structured data. One run captures the full agenda (sessions, times, rooms, tracks, docs), the complete speaker roster with bios and their sessions, sponsors with tiers and logos, and exhibitors with booth numbers. No login. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/scrapesage/whova-event-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.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/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Whova Event Scraper — Sessions, Speakers, Sponsors & Exhibitors

Extract **sessions**, **speakers**, **sponsors**, and **exhibitors** (with **booth numbers** and **sponsor tiers**) from any public Whova event page as clean, structured JSON. **No login / no cookies** — it reads Whova's own public event-webpage data.

### Why this Whova scraper?

| Typical scrapers | This actor |
|---|---|
| Grab one list (just the agenda) | Pulls **four datasets in one run** — sessions, speakers, sponsors, exhibitors |
| Miss the dedicated speaker directory | Merges the **full speaker roster** from the agenda *and* the speaker directory, **deduplicated by profile** |
| Drop breakout sessions | Captures **subsessions** as their own rows, linked to the parent |
| Skip booth/tier metadata | Keeps **exhibitor booth numbers** and **sponsor tiers** |
| Fail on empty sections | Empty results finish as a **successful run** with a plain-English note — no charge |

### Use cases

- **Event lead generation** — pull sponsor and exhibitor companies with websites, logos, tiers, and booth numbers for outreach before or during the show.
- **Conference agenda research** — capture every session's title, time, room, tracks, description, and attached documents for competitive or planning analysis.
- **Speaker sourcing** — build a complete, deduplicated speaker roster with titles, affiliations, bios, and the sessions each person appears in.
- **Expo-floor mapping** — export exhibitors by booth number and category to plan a walk-through or compare year-over-year participation.
- **Multi-event monitoring** — scrape several Whova events at once and track who's sponsoring, exhibiting, or speaking across an industry.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Whova Event Scraper**, fill in the inputs you need, and click **Start**.
3. Watch results stream into the dataset table as each record is parsed.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
  "startUrls": [
    { "url": "https://whova.com/embedded/event/RO1JdFJs9ii6Fx75WrNTg1kBuSNRjetEH9eL7BSaXKQ%3D/" }
  ],
  "includeSessions": true,
  "includeSpeakers": true,
  "includeSponsors": true,
  "includeExhibitors": true,
  "maxItems": 0,
  "maxConcurrency": 5,
  "minDelayMs": 250,
  "maxRequestRetries": 4,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

- **`startUrls`** — public Whova event pages or embedded URLs. Any URL containing the event id works, e.g. `https://whova.com/embedded/event/<event_id>/`. Open an event's public agenda or exhibitor page and copy the long code after `/event/`.
- **`eventIds`** — alternative to URLs: paste raw Whova event ids (the long code after `/event/`, usually ending in `%3D` or `=`).
- **`includeSessions` / `includeSpeakers` / `includeSponsors` / `includeExhibitors`** — toggle each record type (all `true` by default).
- **`maxItems`** — hard cap on total records across all events and types (`0` = no limit).
- **`maxConcurrency`** — how many events to process in parallel (default `5`, max `20`).
- **`minDelayMs`** — politeness delay before each API call (default `250` ms).
- **`maxRequestRetries`** — retries per request on network/HTTP errors; the proxy IP is rotated on each retry (default `4`).
- **`proxyConfiguration`** — uses Apify Proxy (datacenter) by default; recommended.

> **Heads-up on links:** a `whova.com/web/<code>` *app* link won't work on its own — that short code isn't the event id the data needs. Use the **embedded** URL (containing `/embedded/event/`) or the raw id. If you paste something unsupported, the run still finishes successfully and explains how to get the right id.

### Output

Every record carries `recordType`, `eventId`, `eventName`, `sourceUrl`, `scrapedAt`, and `isVirtualEvent`. Missing values are `null` (never invented). Sessions additionally include `parentSessionId` and `isSubsession`, so breakout subsessions are captured as their own rows and linked to their parent. The examples below show the most useful fields per type.

**Session**

```json
{
  "recordType": "session",
  "sessionId": "2917325",
  "name": "The United Kingdom",
  "startTime": "2023-04-22 09:00:00",
  "endTime": "2023-04-22 10:00:00",
  "place": "4th Floor, Venture",
  "description": "The United Kingdom (UK) is at the forefront…",
  "descriptionHtml": "<div><p>…</p></div>",
  "tracks": ["Showcase"],
  "documents": [{ "title": "Slides", "url": "https://…", "description": null }],
  "sessionOrder": 2,
  "speakerNames": ["Michael Kill", "Peter Marks", "Carly Heath", "Philip Kolvin"],
  "speakerCount": 4,
  "eventName": "Sociable City Summit 2023",
  "eventTimezone": "America/New_York"
}
```

**Speaker** (full roster — merged from the agenda + speaker directory, deduplicated by profile)

```json
{
  "recordType": "speaker",
  "profileId": "28928388",
  "name": "Ariel Palitz",
  "title": "Global Government and Hospitality Consultant",
  "affiliation": "NYC Alliance, Oaktree Solutions, Venue Advisors",
  "location": "New York, New York, United States",
  "bio": "…",
  "photoUrl": "https://…",
  "photoIsLinkedinCdn": false,
  "photoIsDefault": false,
  "hasLinkedin": true,
  "hasPicture": true,
  "role": "Speaker",
  "roles": ["Speaker"],
  "sessionIds": ["2931508", "2931510"],
  "sessionCount": 2,
  "socialLinks": { "linkedin": null, "facebook": null, "twitter": null, "instagram": null, "tiktok": null, "youtube": null, "pinterest": null }
}
```

**Sponsor**

```json
{
  "recordType": "sponsor",
  "companyId": "121043",
  "name": "Curb",
  "website": "https://www.gocurb.com/",
  "logoUrl": "https://…",
  "tier": "Advocate",
  "categories": [],
  "boothNumber": null,
  "unpaid": false,
  "description": "…",
  "socialLinks": { "linkedin": null, "facebook": null, "twitter": null, "instagram": null, "tiktok": null, "youtube": null, "pinterest": null },
  "links": []
}
```

**Exhibitor**

```json
{
  "recordType": "exhibitor",
  "companyId": null,
  "name": "3D Group",
  "website": "https://www.3dgroup.net",
  "logoUrl": "https://…",
  "tier": null,
  "categories": [],
  "boothNumber": "215",
  "unpaid": false,
  "description": "360 Feedback - Leadership Coaching - Team Effectiveness…",
  "socialLinks": { "linkedin": null, "facebook": null, "twitter": null, "instagram": null, "tiktok": null, "youtube": null, "pinterest": null },
  "links": []
}
```

Notes:

- Records contain **public, professional/business information only** — no attendee personal contact details (personal email, phone, home address) are ever emitted.
- Many fields are optional and returned as `null` when Whova has no value (e.g. an exhibitor with no tier, a sponsor with no booth).
- **Empty results are reported as success.** If an event has no public data for the types you selected, the run finishes successfully with a plain-English explanation written to the `RUN_SUMMARY` in the run's key-value store, and an empty run is never charged.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it on a cron to keep your data fresh.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/whova-event-scraper').call({
    startUrls: [
        { url: 'https://whova.com/embedded/event/RO1JdFJs9ii6Fx75WrNTg1kBuSNRjetEH9eL7BSaXKQ%3D/' },
    ],
    includeSessions: true,
    includeSpeakers: true,
    includeSponsors: true,
    includeExhibitors: true,
    maxItems: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} records`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new records straight into your CRM or sheet.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a run finds something new.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "pull every sponsor and exhibitor (with booth numbers) from this Whova event page" and let it run this scraper for you.

### More scrapers from scrapesage

Need data from other event platforms and lead sources? Try these:

- [eventbrite-scraper](https://apify.com/scrapesage/eventbrite-scraper) — events plus organizer leads with contacts
- [sched-conference-scraper](https://apify.com/scrapesage/sched-conference-scraper) — conference speakers, sessions, sponsors & leads
- [swapcard-exhibitor-scraper](https://apify.com/scrapesage/swapcard-exhibitor-scraper) — event exhibitors, speakers & contacts
- [bark-listing-scraper](https://apify.com/scrapesage/bark-listing-scraper) — Bark.com service-provider directory listings
- [sam-gov-scraper](https://apify.com/scrapesage/sam-gov-scraper) — US federal contract opportunities & contacts
- [linkedin-jobs-scraper](https://apify.com/scrapesage/linkedin-jobs-scraper) — filter-based LinkedIn job postings, no login
- [facebook-ad-library-scraper](https://apify.com/scrapesage/facebook-ad-library-scraper) — Meta/Instagram competitor ad intelligence
- [google-ads-transparency-scraper](https://apify.com/scrapesage/google-ads-transparency-scraper) — see who's advertising what on Google

### Tips

- Use the **embedded** URL (containing `/embedded/event/`) or the raw event id — a `whova.com/web/<code>` app link won't resolve to the data.
- Keep the default **Apify Proxy (datacenter)** on; the actor rotates the proxy IP on each retry for reliability.
- Set **`maxItems`** to a small number for a test run — the actor samples fairly across all four types so you see every record type, and `RUN_SUMMARY` reports both what was written and what was available. Set it to `0` for everything.
- Toggle off any record type you don't need (e.g. `includeSpeakers: false`) to keep runs focused and cheaper.
- For large events the actor downloads and parses the entire agenda before writing, so the first records can take 1–2 minutes (longer for very large events) and then appear all at once — that startup delay is normal.

### FAQ

**Do I need a Whova login?** No. The actor only reads public event-webpage data — no account, no cookies.

**An event returned 0 exhibitors or 0 sponsors — is it broken?** No. Many events (e.g. summits) have no expo hall or haven't published a section yet. The run succeeds and `RUN_SUMMARY` explains why; empty runs cost nothing.

**Will it get speakers that aren't attached to the agenda?** Yes. Many events keep their roster in a separate speaker directory. The actor pulls that full directory and merges it with any agenda-linked speakers (deduplicated by profile), and even backfills a session's speaker list where the agenda left it blank.

**Where do booth numbers come from?** Whova stores the booth in the exhibitor's `location` field; the actor maps it to `boothNumber`.

**Can I scrape several events at once?** Yes — add multiple URLs or event ids and they're processed in parallel up to `maxConcurrency`.

**Is the data legal to collect?** The actor gathers public, professional/business information only and never emits personal contact details. It is an independent tool and is not affiliated with, endorsed by, or sponsored by Whova. Use it in accordance with the laws and terms that apply to you.

**What export formats are available?** JSON, CSV, Excel, XML, and RSS via the dataset, or programmatically through the Apify API.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

Public Whova event pages or embedded URLs. Any URL containing the event id works, e.g. https://whova.com/embedded/event/\<event\_id>/ . Tip: open an event's public agenda or exhibitor page and copy the long code after /event/ in the address bar.

## `eventIds` (type: `array`):

Alternative to URLs: paste raw Whova event ids (the long code after /event/, usually ending in %3D or =).

## `includeSessions` (type: `boolean`):

Include the agenda's sessions (title, time, room, description, tracks, documents).

## `includeSpeakers` (type: `boolean`):

Include the FULL speaker roster — pulled from BOTH the agenda and the event's dedicated speaker directory, deduplicated by profile, with each speaker's sessions, title, affiliation, bio and photo. Public professional info only.

## `includeSponsors` (type: `boolean`):

Include sponsors (name, website, logo, tier, social links found in the description).

## `includeExhibitors` (type: `boolean`):

Include exhibitors (name, website, logo, booth number, category).

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

Hard cap on total records across all events and types. 0 means no limit.

## `maxConcurrency` (type: `integer`):

How many events to process in parallel.

## `minDelayMs` (type: `integer`):

Politeness delay before each API call (rate limiting).

## `maxRequestRetries` (type: `integer`):

Retries per request on network/HTTP errors (the proxy IP is rotated on each retry).

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

Uses Apify Proxy (datacenter) by default — recommended.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://whova.com/embedded/event/RO1JdFJs9ii6Fx75WrNTg1kBuSNRjetEH9eL7BSaXKQ%3D/"
    }
  ],
  "includeSessions": true,
  "includeSpeakers": true,
  "includeSponsors": true,
  "includeExhibitors": true,
  "maxItems": 0,
  "maxConcurrency": 5,
  "minDelayMs": 250,
  "maxRequestRetries": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        {
            "url": "https://whova.com/embedded/event/RO1JdFJs9ii6Fx75WrNTg1kBuSNRjetEH9eL7BSaXKQ%3D/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/whova-event-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 = { "startUrls": [{ "url": "https://whova.com/embedded/event/RO1JdFJs9ii6Fx75WrNTg1kBuSNRjetEH9eL7BSaXKQ%3D/" }] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/whova-event-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 '{
  "startUrls": [
    {
      "url": "https://whova.com/embedded/event/RO1JdFJs9ii6Fx75WrNTg1kBuSNRjetEH9eL7BSaXKQ%3D/"
    }
  ]
}' |
apify call scrapesage/whova-event-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whova Event Scraper - Sessions, Speakers, Sponsors & Exhibitors",
        "description": "Turn any public Whova event into clean, structured data. One run captures the full agenda (sessions, times, rooms, tracks, docs), the complete speaker roster with bios and their sessions, sponsors with tiers and logos, and exhibitors with booth numbers. No login. Export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "eea4EQmWOo8hGUeLW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~whova-event-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-whova-event-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/scrapesage~whova-event-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-whova-event-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/scrapesage~whova-event-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-whova-event-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": {
                    "startUrls": {
                        "title": "Whova event URLs",
                        "type": "array",
                        "description": "Public Whova event pages or embedded URLs. Any URL containing the event id works, e.g. https://whova.com/embedded/event/<event_id>/ . Tip: open an event's public agenda or exhibitor page and copy the long code after /event/ in the address bar.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "eventIds": {
                        "title": "…or raw Whova event IDs",
                        "type": "array",
                        "description": "Alternative to URLs: paste raw Whova event ids (the long code after /event/, usually ending in %3D or =).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeSessions": {
                        "title": "Scrape sessions",
                        "type": "boolean",
                        "description": "Include the agenda's sessions (title, time, room, description, tracks, documents).",
                        "default": true
                    },
                    "includeSpeakers": {
                        "title": "Scrape speakers",
                        "type": "boolean",
                        "description": "Include the FULL speaker roster — pulled from BOTH the agenda and the event's dedicated speaker directory, deduplicated by profile, with each speaker's sessions, title, affiliation, bio and photo. Public professional info only.",
                        "default": true
                    },
                    "includeSponsors": {
                        "title": "Scrape sponsors",
                        "type": "boolean",
                        "description": "Include sponsors (name, website, logo, tier, social links found in the description).",
                        "default": true
                    },
                    "includeExhibitors": {
                        "title": "Scrape exhibitors",
                        "type": "boolean",
                        "description": "Include exhibitors (name, website, logo, booth number, category).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items (0 = no limit)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total records across all events and types. 0 means no limit.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many events to process in parallel.",
                        "default": 5
                    },
                    "minDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Politeness delay before each API call (rate limiting).",
                        "default": 250
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Retries per request on network/HTTP errors (the proxy IP is rotated on each retry).",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Uses Apify Proxy (datacenter) by default — recommended.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```