# Sched Conference Scraper - Speakers, Sessions, Sponsors & Leads (`scrapesage/sched-conference-scraper`) Actor

Scrape and Sched.com conference: the full speaker roster with bios, job titles, companies and social links, the complete session agenda (times, venues, tracks, descriptions), and sponsors with tiers and logos. Turn conference speakers into B2B leads - no login needed. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapesage/sched-conference-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 speaker scrapeds

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

## Sched Conference Scraper — Speakers, Sessions & Sponsors (Bios, Social Links & Leads)

Extract **complete data from any [Sched](https://sched.com) conference site** — the full **speaker roster with bios and personal social links**, the entire **agenda** (times, venues, tracks, descriptions), and the **sponsor list** with tiers and logos. Every speaker is a ready-to-use **B2B lead**: name, job title, company, profile, social links, and the sessions they speak at.

No login, no cookies, no browser — fast, reliable extraction that works on **any `*.sched.com` event** (KubeCon, MacAdmins, academic and association conferences, summits, and thousands more).

### Why this Sched scraper?

Generic "paste-a-URL" crawlers grab a few visible fields and miss the data that actually matters. This actor reads Sched's public speaker, session, and sponsor pages directly and ships the **richest dataset in the category** — and it merges the speaker roster from **both** the speaker directory **and** every session line-up, so you get the most complete list possible.

| Data | Generic crawlers | This actor |
|---|---|---|
| Speaker name, title, company | partial | ✅ ~95–100% |
| Speaker **full bio** | ❌ | ✅ ~90% |
| Speaker **personal social links** (Twitter/X, LinkedIn, GitHub, website…) | ❌ | ✅ when published |
| Sessions each speaker is presenting | ❌ | ✅ |
| Speaker role (speaker / moderator) | ❌ | ✅ |
| Full agenda: time, venue, track/type, description | partial | ✅ |
| Session → speaker mapping | ❌ | ✅ |
| Sponsors with **tier** (Platinum/Gold…) + logo | ❌ | ✅ |
| Roster merged from directory **+** session line-ups | ❌ | ✅ |
| One clean dataset per entity (no empty columns) | ❌ | ✅ |

### Use cases

- **Lead generation** — conference speakers are senior, in-market decision-makers (founders, VPs, directors). Export them with title, company, and social links and feed your CRM or outreach sequence.
- **Sponsorship & exhibitor prospecting** — see exactly who sponsors an event and at what tier, then pitch competitors and adjacent vendors.
- **Event discovery & aggregation** — power agendas, newsletters, and apps with structured session data: titles, times, rooms, tracks, and descriptions.
- **Competitive & market research** — track who is speaking on which topics, across an entire conference circuit.
- **Recruiting** — find domain experts by topic, with company and links, straight from the speaker roster.

### 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 **Sched Conference Scraper**, paste one or more Sched event URLs (e.g. `https://kccncna2023.sched.com` or just `psumac2024.sched.com`), and choose what to output (**Speakers** by default).
3. Click **Start** and watch results stream into the dataset table.
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
{
    "eventUrls": ["https://kccncna2023.sched.com", "psumac2024.sched.com"],
    "outputType": "speakers",
    "enrichSpeakerProfiles": true
}
````

- **eventUrls** — one or more Sched event sites. Full URL or just the subdomain.
- **outputType** *(default `speakers`)* — `speakers`, `sessions`, or `sponsors` give one clean, dense table; `all` returns everything in one dataset, each row tagged with a `type` field.
- **includeSessions / includeSpeakers / includeSponsors** *(default true)* — which entities to scrape when `outputType` is `all`.
- **enrichSpeakerProfiles** *(default true)* — open each speaker's profile for their full bio, personal social links, and the sessions they present (one page per speaker).
- **enrichSponsorProfiles** *(default false)* — open each sponsor's profile for description and website (one page per sponsor).
- **maxSessions / maxSpeakers** *(default 0 = no limit)* — caps per event, handy for quick test runs.
- **maxConcurrency** *(default 6)* — parallel page fetches.
- **proxyConfiguration** — proxy settings (Apify datacenter proxy by default).

### Output

By default you get **one clean, dense table of speakers** — every column applies to every row. Set `outputType` to `sessions` or `sponsors` for those tables, or `all` to combine everything in one dataset (each row tagged with a `type` of `speaker`, `session`, `sponsor`, or `event`).

A speaker record (`type: "speaker"`):

```json
{
    "type": "speaker",
    "eventUrl": "https://kccncna2023.sched.com",
    "name": "Flynn",
    "company": "Buoyant",
    "position": "Technical Evangelist",
    "role": "speaker",
    "profileUrl": "https://kccncna2023.sched.com/speaker/flynn@buoyant.io",
    "avatarUrl": "https://avatars.sched.co/.../avatar.jpg",
    "bio": "Flynn is a technical evangelist at Buoyant, educating developers about Linkerd…",
    "socialLinks": { "linkedin": "https://www.linkedin.com/in/…", "website": "https://…" },
    "sessions": [
        { "title": "Emissary-Ingress: Self-Service APIs and the Kubernetes Gateway API", "venue": "W196C", "url": "https://kccncna2023.sched.com/event/1R2p0/…" }
    ],
    "sessionCount": 3,
    "scrapedAt": "2026-06-11T12:00:00.000Z"
}
```

A session record (`type: "session"`) carries `title`, `date`, `startTime`/`endTime`, `timezone`, `venue`, `sessionType`, `description`, a `speakers` array, and any `exhibitors`. A sponsor record (`type: "sponsor"`) carries `name`, `tier`, `logoUrl`, `profileUrl`, and optional `website`/`description`.

#### What to expect (field coverage)

Sched is organizer-entered data, so a few fields are populated only when the organizer or speaker filled them in. Verified across multiple conferences, you can typically expect:

| Entity | Always present | Usually present | Present when published |
|---|---|---|---|
| **Speaker** | name, profile URL, role | company ~95%, position ~95%, avatar ~95%, **bio ~90%**, sessions ~98% | `socialLinks` ~50–60% (speakers who added them) |
| **Session** | title, date, start/end, timezone, venue, type | description ~88% | `speakers` / `exhibitors` (sessions that list them) |
| **Sponsor** | name, tier, logo, profile URL | — | website, description (with `enrichSponsorProfiles`) |

A blank field means the organizer didn't publish it for that record — not that scraping failed. Nothing is dropped, so you always get the richest dataset available.

### 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 daily/weekly to capture new speakers and sessions as a conference's agenda fills in.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) 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/sched-conference-scraper').call({
    eventUrls: ['https://kccncna2023.sched.com'],
    outputType: 'speakers',
    enrichSpeakerProfiles: true,
});

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

### 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 speaker leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored conference adds speakers or sessions.
- **[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 "list every speaker at this conference with their company and LinkedIn" and let it run the scraper for you.

### More scrapers from scrapesage

Build a complete **event intelligence & lead-gen stack** — scrape the speaker, attendee, and exhibitor side of the events your prospects run:

- **[Whova Event Scraper](https://apify.com/scrapesage/whova-event-scraper)** — attendees, sessions, speakers, and sponsors from Whova event apps.
- **[Swapcard Exhibitor Scraper](https://apify.com/scrapesage/swapcard-exhibitor-scraper)** — exhibitor lists, speakers, and contacts from Swapcard-powered events.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events plus organizer leads (ticket prices, emails, socials).
- **[Airbnb Scraper](https://apify.com/scrapesage/airbnb-scraper)** — listings, prices, and availability.
- **[Bark Listing Scraper](https://apify.com/scrapesage/bark-listing-scraper)** — service-provider leads from Bark.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — competitor ad intelligence on Meta & Instagram.
- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — who's advertising what on Google.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings as hiring-intent signals.

### Tips

- **Pick a single `outputType`** (Speakers/Sessions/Sponsors) for a clean, fully-populated table that's perfect for direct export. Use `all` when you want everything in one combined dataset (filter on the `type` field, or use the Speakers / Sessions / Sponsors dataset views).
- **Speaker leads**: keep `enrichSpeakerProfiles` on to capture bios and social links — it's the difference between a name and a contactable lead. It adds one fast page per speaker.
- **Big conferences**: speaker enrichment is one request per speaker, so a 400-speaker event makes ~400 requests. For very large rosters, residential proxies run smoother than datacenter.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) to track a conference as its agenda and speaker list grow in the weeks before the event.

### FAQ

**How do I scrape a specific conference?** Put its Sched address in `eventUrls` — the full URL or just the subdomain (`kccncna2023.sched.com`, `psumac2024.sched.com`). You can pass several at once.

**Does it need the Sched API or a key?** No. Sched's official API requires an organizer API key; this actor reads the same (and richer) data from the public speaker, session, and sponsor pages — no key or login needed.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor a conference for new speakers/sessions?** Create a [Schedule](https://docs.apify.com/platform/schedules) (e.g. daily) and optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push new records into your CRM as they appear.

**Where do speaker social links come from?** From each speaker's own Sched profile, where they choose to list their Twitter/X, LinkedIn, GitHub, website, etc. About half of speakers add them — when they don't, the field is simply absent.

**A field is empty — why?** Some speakers don't publish a bio or socials, some sessions have no description, and some events don't list sponsors. Fields are blank only when the organizer didn't publish that data — never because the scraper skipped it.

**Does it include attendees?** No. Sched attendee directories are login-gated by organizers, so they aren't publicly available. This actor covers public speakers, sessions, and sponsors.

**Is scraping Sched legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and Sched's terms.

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

## `eventUrls` (type: `array`):

One or more Sched.com event sites. Accepts the full URL or just the subdomain, e.g. `https://kccncna2023.sched.com` or `psumac2024.sched.com`.

## `outputType` (type: `string`):

What to put in the dataset. A single entity (the default, `Speakers`) gives one clean, dense table — ideal for direct export. `All` returns speakers + sessions + sponsors together in one dataset, with each row tagged by a `type` field; because that combines several record types, the 'All fields' grid will show columns that only apply to other types as blank (this is by design — use a single-entity output for a fully populated table).

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

Extract the full agenda: every session with title, time, venue, type, description and its speakers. (Applies when Output is All.)

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

Extract the speaker roster (merged from the speaker directory and from session line-ups for the most complete list).

## `enrichSpeakerProfiles` (type: `boolean`):

Open each speaker's profile page to also capture their full bio, personal social links (Twitter/X, LinkedIn, GitHub, website…) and the sessions they speak at. Adds one request per speaker.

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

Extract the sponsor/exhibitor list with tier (e.g. Platinum, Gold) and logo, when the event publishes one.

## `enrichSponsorProfiles` (type: `boolean`):

Open each sponsor's profile page to also capture their description and website. Adds one request per sponsor.

## `maxSessions` (type: `integer`):

Limit the number of sessions scraped per event (0 = no limit). Useful for quick test runs.

## `maxSpeakers` (type: `integer`):

Limit the number of speakers scraped per event (0 = no limit). Useful for quick test runs.

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

Maximum number of pages fetched in parallel.

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

Proxy settings. Sched has no aggressive anti-bot, so Apify datacenter proxy (the default) is plenty.

## Actor input object example

```json
{
  "eventUrls": [
    "https://psumac2024.sched.com"
  ],
  "outputType": "speakers",
  "includeSessions": true,
  "includeSpeakers": true,
  "enrichSpeakerProfiles": true,
  "includeSponsors": true,
  "enrichSponsorProfiles": false,
  "maxSessions": 0,
  "maxSpeakers": 0,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Each row is tagged with a `type` (speaker, session, sponsor, or event); use the Speakers / Sessions / Sponsors views to filter the columns.

# 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 = {
    "eventUrls": [
        "https://psumac2024.sched.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/sched-conference-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 = { "eventUrls": ["https://psumac2024.sched.com"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/sched-conference-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 '{
  "eventUrls": [
    "https://psumac2024.sched.com"
  ]
}' |
apify call scrapesage/sched-conference-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sched Conference Scraper - Speakers, Sessions, Sponsors & Leads",
        "description": "Scrape and Sched.com conference: the full speaker roster with bios, job titles, companies and social links, the complete session agenda (times, venues, tracks, descriptions), and sponsors with tiers and logos. Turn conference speakers into B2B leads - no login needed. Export to JSON, CSV or Excel.",
        "version": "0.1",
        "x-build-id": "zWX9k51vyENwUgBLB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~sched-conference-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-sched-conference-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~sched-conference-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-sched-conference-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~sched-conference-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-sched-conference-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",
                "required": [
                    "eventUrls"
                ],
                "properties": {
                    "eventUrls": {
                        "title": "Sched event URLs",
                        "type": "array",
                        "description": "One or more Sched.com event sites. Accepts the full URL or just the subdomain, e.g. `https://kccncna2023.sched.com` or `psumac2024.sched.com`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputType": {
                        "title": "Output",
                        "enum": [
                            "speakers",
                            "sessions",
                            "sponsors",
                            "all"
                        ],
                        "type": "string",
                        "description": "What to put in the dataset. A single entity (the default, `Speakers`) gives one clean, dense table — ideal for direct export. `All` returns speakers + sessions + sponsors together in one dataset, with each row tagged by a `type` field; because that combines several record types, the 'All fields' grid will show columns that only apply to other types as blank (this is by design — use a single-entity output for a fully populated table).",
                        "default": "speakers"
                    },
                    "includeSessions": {
                        "title": "Scrape sessions",
                        "type": "boolean",
                        "description": "Extract the full agenda: every session with title, time, venue, type, description and its speakers. (Applies when Output is All.)",
                        "default": true
                    },
                    "includeSpeakers": {
                        "title": "Scrape speakers",
                        "type": "boolean",
                        "description": "Extract the speaker roster (merged from the speaker directory and from session line-ups for the most complete list).",
                        "default": true
                    },
                    "enrichSpeakerProfiles": {
                        "title": "Enrich speaker profiles",
                        "type": "boolean",
                        "description": "Open each speaker's profile page to also capture their full bio, personal social links (Twitter/X, LinkedIn, GitHub, website…) and the sessions they speak at. Adds one request per speaker.",
                        "default": true
                    },
                    "includeSponsors": {
                        "title": "Scrape sponsors",
                        "type": "boolean",
                        "description": "Extract the sponsor/exhibitor list with tier (e.g. Platinum, Gold) and logo, when the event publishes one.",
                        "default": true
                    },
                    "enrichSponsorProfiles": {
                        "title": "Enrich sponsor profiles",
                        "type": "boolean",
                        "description": "Open each sponsor's profile page to also capture their description and website. Adds one request per sponsor.",
                        "default": false
                    },
                    "maxSessions": {
                        "title": "Max sessions per event",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Limit the number of sessions scraped per event (0 = no limit). Useful for quick test runs.",
                        "default": 0
                    },
                    "maxSpeakers": {
                        "title": "Max speakers per event",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Limit the number of speakers scraped per event (0 = no limit). Useful for quick test runs.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of pages fetched in parallel.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Sched has no aggressive anti-bot, so Apify datacenter proxy (the default) is plenty.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```