# Sessionize Public Events Scraper (`parseforge/sessionize-public-events-scraper`) Actor

Pull sessions, speakers, or session and speaker pairs from any public Sessionize event using its event ID. Returns talk title, abstract, track, room, time slot, speaker name, bio, company, and social links. Useful for conference research, speaker outreach, and event analytics.

- **URL**: https://apify.com/parseforge/sessionize-public-events-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎤 Sessionize Public Events and Speakers Scraper

> 🚀 **Export Sessionize event data in seconds. Sessions, speakers, tracks, rooms, schedules, all from the public Sessionize v2 API.**

> 🕒 **Last updated:** 2026-05-29 · **📊 11 fields** per record · Public Sessionize events worldwide

The Sessionize Public Events Scraper calls Sessionize's public v2 API for any event ID and returns a clean dataset of sessions enriched with speaker details, tracks, rooms, and schedules.

Coverage spans every Sessionize event that has enabled its public API view (most public conferences, meetups, and code camps).

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 📣 Conference organizers | Aggregate sessions across events |
| 🎓 Researchers | Study tech-conference topic trends |
| 📰 Tech journalists | Track speakers and themes |
| 🤝 Sponsors | Identify event audiences |

### 📋 What the Sessionize Scraper does

- Calls `https://sessionize.com/api/v2/{eventId}/view/All`.
- Joins sessions with speakers, tracks, and rooms.
- Returns one row per session, per speaker, or sessions enriched with speaker bios.
- Exports to CSV, Excel, JSON, JSONL, XML, RSS, HTML.

> 💡 **Why it matters:** Sessionize powers most modern tech conferences. Its public API is well-structured but requires multiple joins for usable data. This actor does the joins for you.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>eventId</code></td><td>string</td><td>No</td><td>Sessionize event ID. Find it in the event's embed/API URL.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free: 10. Paid: up to 1M.</td></tr>
<tr><td><code>dataset</code></td><td>enum</td><td>No</td><td>sessions, speakers, or sessions-with-speakers (default).</td></tr>
</table>

**Example 1 — All sessions with speaker bios:**
```json
{ "eventId": "9otadjkk", "dataset": "sessions-with-speakers", "maxItems": 200 }
````

**Example 2 — All speakers:**

```json
{ "eventId": "9otadjkk", "dataset": "speakers", "maxItems": 100 }
```

> ⚠️ **Good to Know:** The event's public API must be enabled by the organizer. Most public conferences enable it. Find the `eventId` in the URL of the Sessionize embed.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `photoUrl` | string | Speaker photo. |
| 🆔 `eventId` | string | Sessionize event ID. |
| 🎤 `eventName` | string | Event title. |
| 📝 `sessionTitle` | string | Session title. |
| 👤 `speakerName` | string | Speaker(s) name(s). |
| 🛤️ `track` | string | Track / category. |
| 📅 `date` | string | Session start time. |
| 🚪 `room` | string | Room name. |
| 📜 `speakerBio` | string | Speaker bio. |
| 🔗 `url` | string | Recording URL if available. |
| 🕒 `scrapedAt` | string | Fetch time. |
| ❌ `error` | string | Errors. |

**Sample record:**

```json
{
  "photoUrl": "https://sessionize.com/image/...jpg",
  "eventId": "9otadjkk",
  "eventName": "DevConf 2026",
  "sessionTitle": "Building Resilient Distributed Systems",
  "speakerName": "Jane Doe",
  "track": "Architecture",
  "date": "2026-06-15T10:00:00",
  "room": "Hall A",
  "speakerBio": "Jane is a Principal Engineer at...",
  "url": null,
  "scrapedAt": "2026-05-29T12:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🔗 | Joins sessions, speakers, tracks, rooms automatically. |
| 🧹 | Clean BI-ready fields. |
| 📅 | Schedule data ready for calendar imports. |
| 🛟 | Errors as clean records. |
| 💾 | CSV / Excel / JSON / XML export. |

### 📈 How it compares to alternatives

| Approach | Setup | Joined data | Multi-event | Speaker bios |
|---|---|---|---|---|
| Raw API | 30 min | ❌ | manual | manual |
| Custom code | 1 hr | partial | partial | partial |
| **This Actor** | 5 sec | ✅ | ✅ | ✅ |

### 🚀 How to use

1. Click **Try for free**.
2. Paste an `eventId`.
3. Pick `dataset` mode.
4. Click **Start**.

### 💼 Business use cases

**📊 Conference research.** Aggregate tracks and topics across many events.

**📣 Speaker outreach.** Build prospect lists of conference speakers.

**🤝 Sponsor decisions.** Compare events by speaker quality and track breadth.

**📰 Journalism.** Track who's keynoting where this season.

### 🔌 Automating Sessionize Scraper

- Make, Zapier, cron, webhooks, BigQuery integrations.

### 🌟 Beyond business use cases

**🎓 Academic.** Study tech-conference topic trends over years.

**🧪 Personal.** Build a personal calendar of must-attend talks.

**🤝 Community.** Power local meetup aggregators.

**🧰 Prototyping.** Event-data demos in seconds.

### 🤖 Ask an AI assistant about this scraper

Drop this README into your AI assistant for workflow mapping.

### ❓ Frequently Asked Questions

**❓ Login?** No.

**❓ Where is `eventId`?** In the Sessionize API URL.

**❓ All events?** Public-API-enabled events only.

**❓ Multi-event?** Run the actor per event, or batch via the API.

**❓ Joined data?** Yes, sessions + speakers + tracks + rooms.

**❓ Schedule?** Yes via Apify.

**❓ Formats?** CSV, Excel, JSON, JSONL, XML, RSS, HTML.

**❓ Official?** No, independent.

**❓ Pagination?** Single API call per event.

**❓ Rate limits?** Reasonable, respect them.

### 🔌 Integrate with any app

Native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, REST API and webhooks.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database. |
| [ParseForge Alpha Vantage Scraper](https://apify.com/parseforge/alpha-vantage-public-scraper) | Market data, FX, crypto. |
| [ParseForge collection](https://apify.com/parseforge) | 900+ scrapers. |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

***

**Disclaimer:** Public data only. ParseForge is independent. Users must comply with Sessionize's ToS. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

## `eventId` (type: `string`):

Sessionize event identifier (the public API ID). Found in the event's embed/API URL (e.g. https://sessionize.com/api/v2/{eventId}/view/All).

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `dataset` (type: `string`):

Which collection to return as rows.

## Actor input object example

```json
{
  "eventId": "9otadjkk",
  "maxItems": 10,
  "dataset": "sessions-with-speakers"
}
```

# Actor output Schema

## `results` (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 = {
    "eventId": "9otadjkk",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/sessionize-public-events-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 = {
    "eventId": "9otadjkk",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/sessionize-public-events-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 '{
  "eventId": "9otadjkk",
  "maxItems": 10
}' |
apify call parseforge/sessionize-public-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sessionize Public Events Scraper",
        "description": "Pull sessions, speakers, or session and speaker pairs from any public Sessionize event using its event ID. Returns talk title, abstract, track, room, time slot, speaker name, bio, company, and social links. Useful for conference research, speaker outreach, and event analytics.",
        "version": "0.1",
        "x-build-id": "q0Gqh2Shyd8PVnzmQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~sessionize-public-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-sessionize-public-events-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/parseforge~sessionize-public-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-sessionize-public-events-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/parseforge~sessionize-public-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-sessionize-public-events-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": {
                    "eventId": {
                        "title": "Event ID",
                        "type": "string",
                        "description": "Sessionize event identifier (the public API ID). Found in the event's embed/API URL (e.g. https://sessionize.com/api/v2/{eventId}/view/All)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "dataset": {
                        "title": "Data type",
                        "enum": [
                            "sessions",
                            "speakers",
                            "sessions-with-speakers"
                        ],
                        "type": "string",
                        "description": "Which collection to return as rows.",
                        "default": "sessions-with-speakers"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```