# Webinar Event Discovery Scraper (`automation-lab/webinar-event-discovery-scraper`) Actor

Discover public webinars, workshops, demos, and B2B event landing pages from domains or URLs with dates, speakers, CTAs, and evidence.

- **URL**: https://apify.com/automation-lab/webinar-event-discovery-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **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.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

## Webinar Event Discovery Scraper

Discover public webinars, workshops, virtual events, product demos, summits, and on-demand event landing pages from company domains or known event URLs.

The actor crawls public B2B marketing pages, follows same-domain event links, extracts structured data when available, and saves normalized records with dates, CTAs, speakers, topics, evidence snippets, and confidence scores.

Use it when you need repeatable event intelligence for lead generation, competitive monitoring, partnership research, content calendars, or CRM enrichment.

### What does Webinar Event Discovery Scraper do?

It turns a list of public websites into a clean dataset of webinar and event opportunities.

- 🔎 Starts from supplied URLs or domains.
- 🧭 Follows same-domain links that look like webinars, events, demos, workshops, summits, conferences, or training pages.
- 🧱 Reads structured `Event` data from JSON-LD when websites publish it.
- 📝 Falls back to page titles, metadata, headings, body text, CTAs, and speaker blocks when structured data is missing.
- 📅 Normalizes dates and status hints.
- 🎯 Finds registration URLs and CTA text.
- 🧪 Adds evidence snippets and confidence scores so humans can review borderline pages quickly.

### Who is it for?

#### Demand generation teams

Track upcoming webinars across target accounts, partners, competitors, and industry publishers.

#### Sales development teams

Find timely campaign hooks and company initiatives to use in outbound messaging.

#### Competitive intelligence teams

Monitor competitor webinars, demos, workshops, and product education pages.

#### Partner marketing teams

Build shared event calendars from partner and ecosystem websites.

#### Content operations teams

Audit old and new event assets across many public resource centers.

### Why use it?

Manual webinar research is repetitive and easy to miss.

This actor helps you:

- Save hours of manual browsing.
- Find registration pages before events happen.
- Detect on-demand webinars that can become lead magnets.
- Standardize messy event pages into one schema.
- Feed CRM, spreadsheets, Slack alerts, or BI dashboards.
- Re-run the same sources every week or month.

### What data can it extract?

| Field | Description |
| --- | --- |
| `sourceUrl` | Page where the event was found |
| `eventTitle` | Webinar or event title |
| `eventType` | Structured type or inferred event type |
| `status` | `upcoming`, `on-demand`, `past`, or `unknown` |
| `startDate` | ISO start date when detected |
| `endDate` | ISO end date when detected |
| `startTime` | Time portion from the start date |
| `endTime` | Time portion from the end date |
| `timezone` | Timezone hint when present |
| `hostCompany` | Organizer, publisher, site name, or domain |
| `speakers` | Speaker or presenter names detected on the page |
| `description` | Metadata or structured event description |
| `agenda` | Short agenda-like evidence line |
| `topics` | Topic keywords inferred from the page |
| `registrationUrl` | Best registration, watch, or CTA URL |
| `ctaText` | CTA anchor/button text |
| `gatedFormProvider` | Hints such as Marketo, HubSpot, ON24, Zoom, or Cvent |
| `evidenceSnippets` | Short snippets proving why the page matched |
| `pageHash` | Stable hash for change detection |
| `discoveredAt` | Extraction timestamp |
| `confidence` | 0-1 score for review prioritization |

### How much does it cost to discover webinar event leads?

Pricing uses pay-per-event output.

You pay a small start fee for each run and then a per-record event fee for saved webinar/event records.

This is useful for monitoring workflows because small tests stay cheap while larger recurring crawls scale with the amount of useful data returned.

### How to use it

1. Open the actor on Apify.
2. Add public event hub URLs or company domains.
3. Keep the default crawl caps for the first run.
4. Optionally set include or exclude keywords.
5. Run the actor.
6. Export the dataset as CSV, JSON, Excel, or via API.
7. Schedule it weekly or monthly for monitoring.

### Input options

#### Start URLs

Use this for known event hubs, resource centers, webinar listing pages, or landing pages.

Examples:

- `https://www.salesforce.com/events/webinars/`
- `https://www.hubspot.com/resources/webinars`
- `https://example.com/events`

#### Domains

Use this when you know the company but not the exact event URL.

Examples:

- `salesforce.com`
- `hubspot.com`
- `example.com`

The actor starts at the homepage and follows event-like same-domain links.

#### Maximum pages per domain

Controls crawler sprawl.

For a quick test, use 5-15 pages per domain.

For a deeper crawl, use 50-100 pages per domain.

#### Maximum event records

Stops the run after this many saved records.

Use a low value for testing and a higher value for scheduled discovery.

#### Include keywords

The default keywords target webinars, events, workshops, demos, summits, conferences, training pages, and on-demand pages.

Add vertical terms like `security`, `AI`, `data`, or `CRM` when you want a tighter dataset.

#### Exclude keywords

Use this to drop irrelevant pages.

Common examples:

- `careers`
- `investor`
- `press release`
- `sponsorship`

#### Status filters

Keep upcoming events, on-demand assets, past events, or unknown pages.

Unknown is useful because many landing pages hide dates inside images or scripts.

#### Date filters

Use `fromDate` and `toDate` when you only want records with detected dates in a specific window.

Pages without dates are not removed by date filters unless a comparable detected date exists.

#### Proxy option

Public B2B marketing pages usually work without a proxy.

Enable Apify Proxy only when a target blocks normal requests.

### Output example

```json
{
  "sourceUrl": "https://www.example.com/events/ai-webinar",
  "eventTitle": "AI Automation Webinar",
  "eventType": "Webinar",
  "status": "upcoming",
  "startDate": "2026-07-10T17:00:00.000Z",
  "endDate": null,
  "startTime": "17:00:00",
  "endTime": null,
  "timezone": "UTC",
  "hostCompany": "example.com",
  "speakers": ["Jane Smith"],
  "description": "Join our AI automation webinar for marketing teams.",
  "agenda": "Learn how to automate webinar follow-up workflows.",
  "topics": ["webinar", "ai", "automation", "marketing"],
  "registrationUrl": "https://www.example.com/events/ai-webinar/register",
  "ctaText": "Register now",
  "gatedFormProvider": "marketo",
  "evidenceSnippets": ["Register now for our AI automation webinar"],
  "pageHash": "abc123def4567890",
  "discoveredAt": "2026-06-25T00:00:00.000Z",
  "confidence": 0.9
}
````

### Tips for better results

- Start with known webinar or event hub URLs when possible.
- Use domains for discovery, then save high-quality event hubs for recurring runs.
- Keep page caps conservative for large enterprise websites.
- Add industry keywords to reduce noisy general event pages.
- Keep `unknown` status enabled if you care about pages where dates are hidden in scripts.
- Use `pageHash` to detect changed pages over time.

### Common workflows

#### Competitive webinar monitoring

Add competitor domains and schedule the actor weekly.

Export upcoming and on-demand records to a spreadsheet or CRM.

#### Account-based marketing research

Add target account domains.

Find recent webinars and demos that reveal strategic priorities.

#### Partner event calendar

Add partner domains.

Collect upcoming workshops and webinars in one dataset.

#### Lead magnet discovery

Keep on-demand status enabled.

Find gated webinars and resource pages for content intelligence.

### Integrations

The dataset can be sent to:

- Google Sheets for campaign planning.
- Airtable for editorial calendars.
- HubSpot or Salesforce for account enrichment.
- Slack for new event alerts.
- Snowflake, BigQuery, or S3 for historical analysis.
- Zapier or Make for no-code automations.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/webinar-event-discovery-scraper').call({
  startUrls: [{ url: 'https://www.salesforce.com/events/webinars/' }],
  maxPagesPerDomain: 20,
  maxResults: 100
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/webinar-event-discovery-scraper").call(run_input={
    "domains": ["salesforce.com"],
    "maxPagesPerDomain": 20,
    "maxResults": 100,
})
print(run["defaultDatasetId"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~webinar-event-discovery-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.salesforce.com/events/webinars/"}],"maxResults":100}'
```

### MCP usage

Use the Apify MCP server with this actor in Claude Code, Claude Desktop, or compatible MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/webinar-event-discovery-scraper
```

Claude Code setup:

```bash
claude mcp add apify-webinar-events https://mcp.apify.com/?tools=automation-lab/webinar-event-discovery-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-webinar-events": {
      "url": "https://mcp.apify.com/?tools=automation-lab/webinar-event-discovery-scraper"
    }
  }
}
```

Example prompts:

- "Find upcoming webinars from these five competitor domains and summarize the topics."
- "Run the webinar event discovery scraper for this partner list and export registration URLs."
- "Compare this week's discovered webinar pages with last week's page hashes."

### Scheduling

Schedule the actor weekly for competitor monitoring or monthly for broad account research.

Use a stable source list and compare `pageHash`, `eventTitle`, and `startDate` between runs.

### Data quality notes

Websites publish event data inconsistently.

The actor combines structured data and heuristics.

Confidence scores help you decide which records need review.

A missing date does not always mean the page is irrelevant.

Some pages hide dates in images, third-party widgets, or scripts.

### FAQ

#### What websites work best?

Public B2B webinar hubs, event pages, demo pages, and resource centers work best. Private portals, login walls, and heavily scripted widgets may need exact URLs or future browser fallback.

#### Can I monitor the same sources repeatedly?

Yes. Schedule the actor and compare `sourceUrl`, `eventTitle`, `startDate`, and `pageHash` across runs.

### Troubleshooting

#### The run saved fewer records than expected

Increase `maxPagesPerDomain`, keep `unknown` status enabled, and add broader include keywords such as `event`, `demo`, and `training`.

#### A page is skipped

The page may be non-HTML, blocked, private, or outside the same domain crawl scope.

Try adding the exact landing page as a start URL.

#### Dates are missing

The site may render dates with JavaScript or images.

Use the evidence snippets and source URL to review those records manually.

#### The crawler visits too many pages

Lower `maxPagesPerDomain`, use more specific start URLs, and add include keywords.

### Legality and responsible use

This actor is designed for public pages only.

Do not use it to bypass login walls, private communities, paywalls, or access controls.

Review each target site's terms and your local laws before running large crawls.

Respect robots, rate limits, and data privacy rules.

### Related scrapers

Related Automation Lab actors that can complement this workflow:

- Website Contact Finder for company contact enrichment.
- Domain to company enrichment actors for account lists.
- Search result scrapers for finding new webinar hubs.
- LinkedIn or company profile scrapers where allowed by their terms.

### Limitations

- Generic crawling cannot guarantee every event page on every website.
- JavaScript-only widgets may require future browser fallback work.
- Registration forms may be embedded by third-party providers.
- Some sites use regional redirects or consent walls.
- Speaker extraction depends on page structure.

### Best practices

- Use high-quality seed URLs.
- Run a small sample first.
- Review confidence scores.
- Export and deduplicate by source URL and title.
- Re-run on a schedule for monitoring.
- Keep source lists organized by segment or competitor set.

### Example source list

```json
{
  "startUrls": [
    { "url": "https://www.salesforce.com/events/webinars/" },
    { "url": "https://www.hubspot.com/resources/webinars" }
  ],
  "maxPagesPerDomain": 25,
  "maxResults": 100,
  "statuses": ["upcoming", "on-demand", "unknown"]
}
```

### Changelog

#### 0.1

Initial private build for public webinar and event discovery.

### Support

If a target website consistently blocks public access, reduce crawl depth, add exact event URLs, or enable proxy for that site.

For best commercial results, keep runs focused on public B2B marketing and event pages.

# Actor input Schema

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

Public webinar, event, resource, blog, or company pages to crawl. Use this for known event hubs or landing pages.

## `domains` (type: `array`):

Optional company domains to probe from the homepage. Example: salesforce.com

## `maxPagesPerDomain` (type: `integer`):

Hard cap for each domain to prevent crawler sprawl on large marketing sites.

## `maxResults` (type: `integer`):

Stop after this many webinar/event records are saved.

## `includeKeywords` (type: `array`):

Only keep pages/records that contain at least one of these words. Leave empty for webinar/event defaults.

## `excludeKeywords` (type: `array`):

Drop records containing these words, such as careers or investor events.

## `statuses` (type: `array`):

Filter by inferred event status. Unknown keeps pages where the date is missing but the content looks like an event.

## `fromDate` (type: `string`):

Optional ISO date lower bound for records with a detected start date.

## `toDate` (type: `string`):

Optional ISO date upper bound for records with a detected start date.

## `useProxy` (type: `boolean`):

Enable only when a target blocks normal datacenter access. Public B2B event pages usually work without proxy.

## `proxyCountryCode` (type: `string`):

Optional ISO country code for Apify Proxy sessions, for example US or GB.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for each public page.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.salesforce.com/events/webinars/"
    },
    {
      "url": "https://www.atlassian.com/webinars"
    }
  ],
  "domains": [
    "salesforce.com"
  ],
  "maxPagesPerDomain": 12,
  "maxResults": 20,
  "includeKeywords": [
    "webinar",
    "event",
    "workshop",
    "demo"
  ],
  "excludeKeywords": [],
  "statuses": [
    "upcoming",
    "on-demand",
    "unknown"
  ],
  "useProxy": false,
  "proxyCountryCode": "US",
  "requestTimeoutSecs": 20
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.salesforce.com/events/webinars/"
        },
        {
            "url": "https://www.atlassian.com/webinars"
        }
    ],
    "domains": [
        "salesforce.com"
    ],
    "maxPagesPerDomain": 12,
    "maxResults": 20,
    "includeKeywords": [
        "webinar",
        "event",
        "workshop",
        "demo"
    ],
    "excludeKeywords": [],
    "statuses": [
        "upcoming",
        "on-demand",
        "unknown"
    ],
    "useProxy": false,
    "proxyCountryCode": "US",
    "requestTimeoutSecs": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/webinar-event-discovery-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://www.salesforce.com/events/webinars/" },
        { "url": "https://www.atlassian.com/webinars" },
    ],
    "domains": ["salesforce.com"],
    "maxPagesPerDomain": 12,
    "maxResults": 20,
    "includeKeywords": [
        "webinar",
        "event",
        "workshop",
        "demo",
    ],
    "excludeKeywords": [],
    "statuses": [
        "upcoming",
        "on-demand",
        "unknown",
    ],
    "useProxy": False,
    "proxyCountryCode": "US",
    "requestTimeoutSecs": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/webinar-event-discovery-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://www.salesforce.com/events/webinars/"
    },
    {
      "url": "https://www.atlassian.com/webinars"
    }
  ],
  "domains": [
    "salesforce.com"
  ],
  "maxPagesPerDomain": 12,
  "maxResults": 20,
  "includeKeywords": [
    "webinar",
    "event",
    "workshop",
    "demo"
  ],
  "excludeKeywords": [],
  "statuses": [
    "upcoming",
    "on-demand",
    "unknown"
  ],
  "useProxy": false,
  "proxyCountryCode": "US",
  "requestTimeoutSecs": 20
}' |
apify call automation-lab/webinar-event-discovery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Webinar Event Discovery Scraper",
        "description": "Discover public webinars, workshops, demos, and B2B event landing pages from domains or URLs with dates, speakers, CTAs, and evidence.",
        "version": "0.1",
        "x-build-id": "euV2pl7nRWQni3xv3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~webinar-event-discovery-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-webinar-event-discovery-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~webinar-event-discovery-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-webinar-event-discovery-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~webinar-event-discovery-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-webinar-event-discovery-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": "Start URLs",
                        "type": "array",
                        "description": "Public webinar, event, resource, blog, or company pages to crawl. Use this for known event hubs or landing pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "Optional company domains to probe from the homepage. Example: salesforce.com",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Maximum pages per domain",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Hard cap for each domain to prevent crawler sprawl on large marketing sites.",
                        "default": 25
                    },
                    "maxResults": {
                        "title": "Maximum event records",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many webinar/event records are saved.",
                        "default": 20
                    },
                    "includeKeywords": {
                        "title": "Include keywords",
                        "type": "array",
                        "description": "Only keep pages/records that contain at least one of these words. Leave empty for webinar/event defaults.",
                        "default": [
                            "webinar",
                            "event",
                            "workshop",
                            "demo",
                            "summit",
                            "conference",
                            "training",
                            "on-demand"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords",
                        "type": "array",
                        "description": "Drop records containing these words, such as careers or investor events.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "statuses": {
                        "title": "Statuses to include",
                        "type": "array",
                        "description": "Filter by inferred event status. Unknown keeps pages where the date is missing but the content looks like an event.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "upcoming",
                                "on-demand",
                                "past",
                                "unknown"
                            ],
                            "enumTitles": [
                                "Upcoming",
                                "On-demand",
                                "Past",
                                "Unknown"
                            ]
                        },
                        "default": [
                            "upcoming",
                            "on-demand",
                            "unknown"
                        ]
                    },
                    "fromDate": {
                        "title": "From date",
                        "type": "string",
                        "description": "Optional ISO date lower bound for records with a detected start date."
                    },
                    "toDate": {
                        "title": "To date",
                        "type": "string",
                        "description": "Optional ISO date upper bound for records with a detected start date."
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable only when a target blocks normal datacenter access. Public B2B event pages usually work without proxy.",
                        "default": false
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "type": "string",
                        "description": "Optional ISO country code for Apify Proxy sessions, for example US or GB.",
                        "default": "US"
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum time to wait for each public page.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
