# LinkedIn Event Finder with Speaker & Venue Details (`dataspryva/linkedin-event-finder-with-speaker-and-venue`) Actor

Find LinkedIn events by keyword or fetch specific event pages: dates, format, organizer, attendee count, speaker lineup, venue address and registration link.

- **URL**: https://apify.com/dataspryva/linkedin-event-finder-with-speaker-and-venue.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Social media, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Community Event Scraper — Webinars & Past Events

Scrape the public **LinkedIn Sales Community** and **LinkedIn Talent Community** event calendars without cookies, login, or proxy setup. Search by keyword, browse every upcoming or past event, or paste event URLs to get exact schedules, timezones, descriptions, cover images, registration links, categories, and languages as clean structured rows.

The actor is fully cookieless: no cookies, no login, and no proxy configuration are required. It uses the two public LinkedIn community event sites, which publish their event pages openly. Main `www.linkedin.com/events/<id>` pages are login-walled, so those URLs return their real id and slug, plus optional archived guest-page details when a Wayback Machine snapshot exists.

### What this actor does

- **Three modes:** `search` by keyword, `browse` the full inventory, `byUrls` for specific event pages
- **Exact schedules:** ISO 8601 start/end timestamps in UTC plus the event's IANA timezone
- **Rich event content:** description text, cover image, external registration URL and label, category, language
- **Both communities:** Sales (scommunity) and Talent (tcommunity), upcoming and past
- **Honest output:** empty fields are omitted, never filled with placeholders

### Output per event

- `eventName` — event title
- `eventUrl` — canonical public event page
- `eventId`, `eventSlug` — event identifier and URL slug
- `community` — `LinkedIn Sales Community` or `LinkedIn Talent Community`
- `organizerName`, `organizerUrl` — the publishing community
- `startDate`, `endDate` — exact start/end, ISO 8601 UTC
- `startTime`, `endTime` — legacy mirrors of the same values
- `timezone` — IANA zone, e.g. `Europe/Dublin`
- `format` — `ONLINE`, `IN_PERSON`, or `HYBRID`
- `eventType` — `VIRTUAL`, `IN_PERSON`, or `HYBRID`
- `eventCategory` — the source label, e.g. `ENGLISH`, `RECRUITER`, `SEARCH & STAFFING`
- `language` — ISO code when the source label is a language (`en`, `es`, `fr`, `de`, `pt`, `it`, `nl`, `zh`, `ja`)
- `description` — full event description text (omitted when `includeDescriptions` is false)
- `coverImageUrl` — event cover image (live community events)
- `registrationUrl`, `registrationUrlLabel` — external registration page and the source's button label
- `attendeesCount`, `attendeeCount` — only when the source reports a non-zero count
- `address` — structured venue, only for archived in-person main events that expose one
- `locationText` — free-text venue from an archived guest page
- `scheduleText` — date text from an archived guest page
- `archiveSnapshotUrl` — Wayback snapshot used for a main event URL
- `sourceType` — `community`, `archive`, or `linkedin`
- `scrapedAt` — UTC scrape timestamp

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browse` / `byUrls` |
| `searchQuery` | string | – | Keyword over event titles (mode=`search`); empty returns all events |
| `eventUrls` | array | – | Event URLs (mode=`byUrls`) |
| `communities` | string | `both` | `both` / `sales` / `talent` (mode=`search`/`browse`) |
| `eventTiming` | string | `upcoming` | `upcoming` / `past` / `all` (mode=`search`/`browse`) |
| `eventFormat` | string | any | `VIRTUAL` / `IN_PERSON` / `HYBRID` (mode=`search`/`browse`) |
| `language` | string | any | ISO language code (mode=`search`/`browse`) |
| `maxEvents` | integer | `50` | Hard cap, 1–1000 |
| `includeDescriptions` | boolean | `true` | Add full description text |
| `includeArchivedDetails` | boolean | `false` | Enrich main event URLs from the Wayback Machine |

#### Example: keyword search across both communities

```json
{
  "mode": "search",
  "searchQuery": "sales navigator",
  "communities": "both",
  "eventTiming": "upcoming",
  "maxEvents": 25
}
```

#### Example: every past Talent Community event

```json
{
  "mode": "browse",
  "communities": "talent",
  "eventTiming": "past",
  "maxEvents": 100
}
```

#### Example: fetch community event URLs

```json
{
  "mode": "byUrls",
  "eventUrls": [
    "https://scommunity.linkedin.com/events/how-i-sell-with-sales-navigator-tamika-brunetti-231",
    "https://tcommunity.linkedin.com/events/hiring-at-speed-how-recruiters-are-reducing-time-to-hire-123"
  ]
}
```

#### Example: a main LinkedIn event URL with archived details

```json
{
  "mode": "byUrls",
  "eventUrls": ["https://www.linkedin.com/events/040-thepowerofcelebration7350512302091104257/"],
  "includeArchivedDetails": true
}
```

### Use cases

- **Event marketing** — track the webinars LinkedIn's own communities run for sales and recruiting audiences
- **Sales enablement** — build a calendar of Sales Navigator training sessions and product deep-dives
- **Recruiting research** — follow Talent Community hiring webinars, recruiter workshops, and instructor-led sessions
- **Content planning** — compare topics, categories, and languages across upcoming and past events
- **Historical analysis** — export hundreds of past community events with schedules and registration links
- **CRM enrichment** — add public event URLs, registration pages, and descriptions to your event records

### FAQ

**Do I need a LinkedIn account or cookie?**
No. The actor reads the public Sales and Talent community event pages, which are served without login. There is no cookie, token, or proxy input.

**Which LinkedIn events are covered?**
The two public community calendars: `scommunity.linkedin.com/events` (Sales) and `tcommunity.linkedin.com/events` (Talent). Both upcoming and past tabs are supported, and every event detail page is parsed.

**Why can't I get details for a normal www.linkedin.com/events link?**
Live main LinkedIn event pages redirect to the login wall, so they are not publicly readable. The actor returns the event id and slug from the URL, and can optionally add name, host, date text, description, and venue from a public Wayback Machine guest snapshot. Archived cover images are omitted because their signed LinkedIn CDN URLs expire and Wayback replays them with 403/429.

**Why are attendee counts and speaker lists missing?**
Attendee identities and counts require a logged-in member, and the public event pages do not expose a structured speaker field. The actor does not fabricate them; it emits only fields the public source actually provides.

**Why are all community events marked virtual?**
The Sales and Talent communities currently publish virtual events only. If an in-person event appears later, the format is taken from the source rather than assumed.

**What is the difference between `eventCategory` and `language`?**
The source uses one label for both topic and language. `eventCategory` keeps the raw label (e.g. `RECRUITER`), while `language` is filled only when that label is a known language (e.g. `DEUTSCH` becomes `de`).

**Why does a language filter return fewer events?**
Some community events are labelled with a topic such as `RECRUITER` instead of a language. When you set a language filter, those unlabelled events are omitted rather than guessed.

**Does search look inside descriptions?**
No. The public listing pages have no server-side search, so keyword matching runs over event titles. Browse the full inventory if you need every event in a category.

**How fresh is the data?**
Every run reads the live community calendars and event pages, so schedules, descriptions, images, and registration links reflect the source at scrape time.

**Is this affiliated with LinkedIn?**
No. This is an independent, third-party actor. It uses publicly accessible event pages and is not affiliated with or endorsed by LinkedIn Corporation.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Keyword filter over event titles (mode=search). Leave empty to return every event. Matching is case- and accent-insensitive.

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

Community event URLs (scommunity.linkedin.com/events/... or tcommunity.linkedin.com/events/...) or main www.linkedin.com/events/<id> URLs (mode=byUrls).

## `communities` (type: `string`):

Which public LinkedIn community sites to scan (mode=search/browse).

## `eventTiming` (type: `string`):

Which listing tab to scan (mode=search/browse).

## `eventFormat` (type: `string`):

Filter by format (mode=search/browse). Public community events are virtual; other values legitimately return 0.

## `language` (type: `string`):

Keep events whose source label is this language (mode=search/browse). Events labelled with a topic instead of a language are omitted when this filter is set.

## `maxEvents` (type: `integer`):

Hard cap on emitted records. A direct event URL always returns its one event.

## `includeDescriptions` (type: `boolean`):

Add the full event description text. Schedules, timezones, images, registration links and categories are always fetched.

## `includeArchivedDetails` (type: `boolean`):

For main www.linkedin.com/events URLs only (mode=byUrls): look for a public Wayback Machine guest snapshot with name, host, date text, description and venue (when archived). Archived cover images are omitted because their signed CDN URLs are expired.

## Actor input object example

```json
{
  "mode": "browse",
  "searchQuery": "",
  "communities": "both",
  "eventTiming": "all",
  "eventFormat": "",
  "language": "",
  "maxEvents": 1,
  "includeDescriptions": false,
  "includeArchivedDetails": false
}
```

# Actor output Schema

## `events` (type: `string`):

Dataset containing all scraped public LinkedIn community events.

# 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 = {
    "mode": "browse",
    "searchQuery": "",
    "communities": "both",
    "eventTiming": "all",
    "eventFormat": "",
    "language": "",
    "maxEvents": 1,
    "includeDescriptions": false,
    "includeArchivedDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/linkedin-event-finder-with-speaker-and-venue").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 = {
    "mode": "browse",
    "searchQuery": "",
    "communities": "both",
    "eventTiming": "all",
    "eventFormat": "",
    "language": "",
    "maxEvents": 1,
    "includeDescriptions": False,
    "includeArchivedDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/linkedin-event-finder-with-speaker-and-venue").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "browse",
  "searchQuery": "",
  "communities": "both",
  "eventTiming": "all",
  "eventFormat": "",
  "language": "",
  "maxEvents": 1,
  "includeDescriptions": false,
  "includeArchivedDetails": false
}' |
apify call dataspryva/linkedin-event-finder-with-speaker-and-venue --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/linkedin-event-finder-with-speaker-and-venue"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zMzIbNHjRIL71nQch/builds/Og7UzMCKd89uKWiXG/openapi.json