# LinkedIn Events Scraper (`automation-lab/linkedin-events-scraper`) Actor

Discover public LinkedIn events and extract event details, schedules, organizers, locations, and registration metadata.

- **URL**: https://apify.com/automation-lab/linkedin-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 3 total users, 2 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## LinkedIn Events Scraper

Discover publicly indexed **LinkedIn events** by keyword or event URL without supplying a LinkedIn login.
The Actor returns one typed dataset row per event with its stable ID, canonical URL, title, indexed description, schedule text, organizer, location, attendance count, virtual-event signal, and external registration URL when those fields are publicly indexed.

Use it to refresh event intelligence, build organizer calendars, discover webinars, prepare partnership research, or feed public event records into a spreadsheet, CRM, database, or monitoring workflow.

### What LinkedIn Events Scraper does

The Actor searches the public web index for LinkedIn event pages rather than signing in to LinkedIn.
It supports two input routes:

- **Keyword discovery** — search by topic, organizer, industry, city, event format, or year.
- **Event URL resolution** — submit one or more known `linkedin.com/events/...` URLs and resolve the matching indexed record.

Results are deduplicated by LinkedIn's stable numeric event ID.
The Actor applies the same output contract to discovered events and explicit URLs.
It never asks for LinkedIn credentials or cookies.

### Who is it for

#### Event intelligence teams

Refresh public calendars of webinars, conferences, product launches, and professional community events.

#### B2B marketing and partnerships teams

Find events relevant to an industry, organizer, account list, or campaign theme before planning sponsorships and outreach.

#### Analysts and researchers

Export event titles, descriptions, public schedules, and registration links for one-time or recurring analysis.

#### Automation builders

Send deduplicated event records to Google Sheets, Airtable, a warehouse, an Apify webhook, Make, Zapier, n8n, or your own API.

#### Developers and AI agents

Call the Actor through the Apify API or MCP and receive JSON records instead of parsing search pages themselves.

### Why use this Actor

- No LinkedIn login, password, or session cookie is required.
- Both keyword queries and real event URLs use one stable output schema.
- Numeric event IDs provide deterministic deduplication across repeated runs.
- Bounded retries and conservative pacing handle temporary search throttling.
- `maxItems` and per-query page limits keep runs predictable.
- Pay-per-event billing means failed, duplicate, and rejected records are not charged as event items.
- Null fields are explicit; the Actor does not invent organizer, attendance, location, or registration data.

### What data can be extracted

| Field | Type | Meaning |
| --- | --- | --- |
| `eventId` | string | Stable numeric LinkedIn event identifier. |
| `eventUrl` | string | Canonical public LinkedIn event URL returned by the index. |
| `title` | string | Indexed event title. |
| `description` | string or null | Indexed event description or search snippet. |
| `dateText` | string or null | Public date or schedule text, kept as displayed by the index. |
| `organizerName` | string or null | Organizer only when explicit hosted-by, organized-by, or presented-by text exists. |
| `location` | string or null | Explicit venue/location text, or `Online` for a clearly virtual event. |
| `attendanceCount` | integer or null | Public attendee, going, or registration count when indexed. |
| `registrationUrl` | string or null | External, non-LinkedIn registration URL when indexed. |
| `isVirtual` | boolean or null | Virtual/in-person signal only when the indexed text makes it explicit. |
| `sourceQuery` | string | Keyword or event URL that produced the row. |
| `sourceType` | string | `query` or `url`. |
| `searchResultRank` | integer | Deduplicated output order for this run. |
| `pageNumber` | integer | Search page where the event was found. |
| `scrapedAt` | string | UTC extraction timestamp. |

Field completeness depends on what the public search index exposes for each event.
A null value means the field was not present clearly enough to extract safely.

### How to get started

1. Open the Actor input page.
2. Add one or more values to **Event search queries**, such as `AI webinar` or `cybersecurity conference`.
3. Optionally add known LinkedIn event URLs under **LinkedIn event URLs**.
4. Choose a practical `maxItems` value.
5. Keep one search page per query for a quick run, or increase the page limit for broader indexed coverage.
6. Select a language-market preference such as `en-US` or `de-DE`.
7. Start the Actor.
8. Open the **LinkedIn events** dataset view or export the dataset as JSON, CSV, Excel, XML, or RSS.

Start with narrow, descriptive queries.
Adding an organizer, topic, region, or year usually produces more relevant records than a one-word query.

### Input parameters

#### `queries`

An array of public event search phrases.
The Actor automatically scopes every phrase to LinkedIn event pages.
Do not add `site:linkedin.com/events/` yourself.

Examples:

```json
[
  "AI webinar",
  "Microsoft future of work event",
  "cybersecurity conference London"
]
```

#### `startUrls`

Optional LinkedIn event URLs.
Both numeric URLs and slug-plus-ID URLs are accepted.
Other LinkedIn pages and non-LinkedIn URLs fail input validation.

```json
[
  { "url": "https://www.linkedin.com/events/7038508574142074880/" }
]
```

Set `queries` to an empty array when you want a URL-only run.

#### `maxItems`

Maximum unique event rows saved across all inputs.
The default is 50 and the maximum is 1,000.
The Actor stops accepting rows as soon as this limit is reached.

#### `maxPagesPerQuery`

Maximum public search pages requested for each query or URL.
The default is 2 and the maximum is 10.
More pages can increase coverage, runtime, and the chance of temporary index throttling.

#### `market`

Language-market preference sent to the public index.
Use values such as `en-US`, `en-GB`, `de-DE`, or `es-ES`.
This influences result language and ranking; it is not a strict geographic event filter.

#### `requestDelayMillis`

Delay between search pages.
The default is 1,500 milliseconds.
Increase it for large recurring runs if the index starts returning temporary throttling responses.

### Example input: discover AI webinars

```json
{
  "queries": ["AI webinar"],
  "startUrls": [],
  "maxItems": 5,
  "maxPagesPerQuery": 1,
  "market": "en-US",
  "requestDelayMillis": 1500
}
```

### Example input: resolve an event URL

```json
{
  "queries": [],
  "startUrls": [
    { "url": "https://www.linkedin.com/events/7038508574142074880/" }
  ],
  "maxItems": 1,
  "maxPagesPerQuery": 1,
  "market": "en-US"
}
```

### Example output

This record reflects the Actor's current URL-resolution behavior:

```json
{
  "eventId": "7038508574142074880",
  "eventUrl": "https://www.linkedin.com/events/7038508574142074880/",
  "title": "The Future of Work: Reinventing Productivity with AI",
  "description": "Join us for a special event with Satya Nadella and Jared Spataro to learn how AI will power a whole new way of working for every person and organization. The live stream starts at 8 AM Pacific Time on March 16.",
  "dateText": "March 16",
  "organizerName": null,
  "location": null,
  "attendanceCount": null,
  "registrationUrl": null,
  "isVirtual": true,
  "sourceQuery": "https://www.linkedin.com/events/7038508574142074880/",
  "sourceType": "url",
  "searchResultRank": 1,
  "pageNumber": 1,
  "scrapedAt": "2026-07-31T02:12:51.429Z"
}
```

The example shows why nullable fields matter: a useful public event identity and description can be available even when the index does not expose organizer or attendance metadata.

### How much does it cost to discover LinkedIn events?

This Actor uses pay-per-event pricing:

- one small **Start** charge is applied once per run;
- one **Item processed** charge is applied for each unique event row saved;
- duplicate, malformed, empty, and failed candidates do not create item charges;
- per-item prices decrease through Apify's volume tiers.

The active one-time start price is **$0.005 per run**. Active item prices are:

| Apify tier | Price per saved event |
| --- | ---: |
| FREE | $0.020392 |
| BRONZE | $0.017732 |
| SILVER | $0.013831 |
| GOLD | $0.010639 |
| PLATINUM | $0.0070928 |
| DIAMOND | $0.004965 |

At BRONZE pricing, a run saving 1 event costs about **$0.0227**, 10 events about **$0.1823**, 25 events about **$0.4483**, and 100 events about **$1.7782**, including the start charge.
The same calculation is `0.005 + saved events × your active item-tier price`.
A URL-only test with one saved row is the cheapest way to verify that the output fits your workflow.
Larger recurring searches benefit from lower per-event volume tiers.

Infrastructure usage, including the Actor's datacenter proxy requests, is covered by the pay-per-event model rather than billed as a separate output type.

### Event discovery workflow patterns

#### Build a public webinar calendar

Schedule daily or weekly queries for a topic and append records to a warehouse.
Use `eventId` as the primary key and compare the nullable metadata fields between runs.

#### Monitor an organizer and topic together

Use several focused phrases such as `Microsoft AI event` and `Microsoft future of work event`.
Deduplicate downstream on `eventId` and preserve `sourceQuery` to explain why each record matched.

#### Enrich a known URL list

Feed event URLs collected from posts, newsletters, or CRM notes into `startUrls`.
Set `queries` to `[]` and retain the output alongside the original URL source.

#### Export to a spreadsheet

Open the run dataset, choose CSV or Excel, and select the overview fields.
For scheduled exports, fetch the default dataset through the API after each successful run.

#### Trigger downstream automation

Configure an Apify webhook for successful runs.
Pass the dataset ID to Make, Zapier, n8n, or an internal worker that loads new event rows.

### API usage with cURL

Set `APIFY_TOKEN` in your environment and run:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~linkedin-events-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["AI webinar"],
    "startUrls": [],
    "maxItems": 10,
    "maxPagesPerQuery": 1,
    "market": "en-US"
  }'
```

To wait for completion and receive dataset items directly:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~linkedin-events-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["AI webinar"],"maxItems":5,"maxPagesPerQuery":1}'
```

Do not commit your Apify token to source control.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/linkedin-events-scraper').call({
  queries: ['Microsoft AI event'],
  startUrls: [],
  maxItems: 20,
  maxPagesPerQuery: 2,
  market: 'en-US',
});

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

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/linkedin-events-scraper").call(run_input={
    "queries": ["cybersecurity conference"],
    "startUrls": [],
    "maxItems": 20,
    "maxPagesPerQuery": 2,
    "market": "en-US",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in items:
    print(item["eventId"], item["title"], item["eventUrl"])
```

### Use LinkedIn Events Scraper with MCP

#### Claude Code setup

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/linkedin-events-scraper"
```

#### Claude Desktop setup

Use this HTTP MCP configuration in Claude Desktop:

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

#### Cursor setup

Add the same `mcpServers.apify.url` value in Cursor's MCP settings.

#### VS Code setup

Add the same HTTP MCP server URL through your VS Code MCP extension or workspace MCP settings.

Example prompts:

- “Run LinkedIn Events Scraper for AI webinars and return at most 10 events.”
- “Resolve this LinkedIn event URL and summarize only metadata present in the dataset.”
- “Search for Microsoft future-of-work events and format the resulting event IDs and URLs as CSV.”

MCP clients still use your Apify account and the Actor's active pricing.

### Reliability and failure behavior

The Actor retries temporary network, HTTP 429, and server failures with bounded exponential backoff.
It does not retry malformed URLs or permanent client errors indefinitely.

If every search request fails, the run fails instead of silently returning an empty successful dataset.
If a valid query has no indexed matches, the run can succeed with zero rows.
When one query fails but another succeeds, the Actor records a warning and preserves useful rows from the successful query.

Use conservative page counts and delays for recurring workloads.
Split very large topic lists across scheduled runs if relevance and freshness matter more than one large batch.

### Limits and data freshness

- The Actor reads public search-index records, not LinkedIn's private authenticated event API.
- LinkedIn can require login when opening the event URL even though the public index still contains metadata.
- Index coverage and freshness are controlled by the search provider and LinkedIn.
- Deleted, private, login-only, or newly created events may be absent.
- Historic events can rank for broad queries; include a year or specific organizer when that matters.
- Schedule text is kept as indexed text because timezone and year may be omitted.
- Organizer, attendance, location, and registration metadata are nullable.
- `market` influences ranking and language but does not guarantee event geography.
- The Actor does not scrape attendees, profiles, private conversations, or login-only fields.

### Tips for better results

- Combine a topic with `webinar`, `conference`, `summit`, `workshop`, or a year.
- Include an organizer or company for calendar-refresh workflows.
- Use multiple narrow queries instead of one very broad phrase.
- Keep `maxPagesPerQuery` at 1 while validating a new query.
- Store `eventId` as your downstream unique key.
- Compare nullable metadata across scheduled runs rather than assuming every field is always present.
- Set `queries` to `[]` for URL-only resolution.
- Inspect warnings before increasing request volume.

### Responsible and legal use

Only collect public event information for a legitimate purpose.
Follow LinkedIn's terms, the event organizer's terms, applicable privacy and database laws, and your organization's data-retention policy.

Do not use the Actor to infer sensitive traits, evade access controls, scrape private event participation, or automate unsolicited outreach.
Avoid combining public event records with personal data unless you have a lawful basis and appropriate safeguards.

You are responsible for deciding whether your intended collection and downstream use are permitted in your jurisdiction.
This documentation is operational guidance, not legal advice.

### Troubleshooting

#### Why did my query return no events?

Try a more specific phrase, add a year or organizer, and test the same phrase in another supported market.
The public index may not contain a new, private, deleted, or login-only event.
A successful zero-row run is possible when no public result matches.

#### Why are some metadata fields null?

The Actor only returns organizer, schedule, location, attendance, and registration values when they are explicit in indexed text.
Null is safer than an inferred or fabricated value.
The canonical URL, ID, title, and description can still make the row useful.

#### Why does the event URL open a login page?

LinkedIn controls its first-party event page separately from the public search index.
This Actor extracts publicly indexed metadata without promising that every event detail page remains guest-accessible.

#### What should I do after throttling warnings?

Reduce `maxPagesPerQuery`, increase `requestDelayMillis`, or split the query list into smaller scheduled runs.
Do not repeatedly restart an unchanged failing run.

#### Why was my URL rejected?

Only `linkedin.com/events/<numeric-id>/` and `linkedin.com/events/<slug-with-numeric-id>/` forms are accepted.
Company, post, profile, generic events-directory, and non-LinkedIn URLs are rejected intentionally.

### FAQ

#### Does this Actor require LinkedIn cookies?

No.
It uses public search-index pages and does not accept a LinkedIn username, password, or cookie.

#### Can it discover events by organizer?

Yes, include the organizer name in a query.
This is public index matching, not a guaranteed complete organizer directory.

#### Does it return event attendees?

No.
It can return a public attendance count when indexed, but it does not collect attendee identities or profiles.

#### Can I schedule recurring runs?

Yes.
Use Apify Schedules and keep `eventId` as the downstream key for new/changed-record comparisons.

#### Can I export to CSV or Excel?

Yes.
Every run writes normal Apify dataset items, which can be downloaded in JSON, JSONL, CSV, Excel, XML, and RSS formats.

#### Are the results real-time?

No.
They reflect the public search index at run time, and index freshness varies.

#### Will explicit URLs always return a row?

No.
The event must be publicly indexed, and the numeric event ID must match the returned result.

### Related Automation Lab Actors

- [LinkedIn Public Profile Search Scraper](https://apify.com/automation-lab/linkedin-public-profile-search-scraper) — discover public professional profiles after identifying relevant event organizers or speakers.
- [Webinar Landing Page Extractor](https://apify.com/automation-lab/webinar-landing-page-extractor) — extract structured details from external webinar and registration landing pages found in event metadata.

Choose this Actor for LinkedIn event identity and indexed metadata.
Choose Webinar Landing Page Extractor when the external registration page is the primary source you need to parse.

# Actor input Schema

## `queries` (type: `array`):

Keywords describing the events to discover, such as a topic, organizer, industry, city, or year. The Actor automatically scopes each query to public LinkedIn event pages.

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

Optional public linkedin.com/events URLs to resolve from the public search index. Numeric and slug-plus-ID event URLs are supported.

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

Maximum number of unique event records saved across all queries and URLs.

## `maxPagesPerQuery` (type: `integer`):

Maximum public search result pages requested for each keyword or event URL.

## `market` (type: `string`):

Language-market preference sent to the public search index, for example en-US, en-GB, de-DE, or es-ES.

## `requestDelayMillis` (type: `integer`):

Conservative delay between public search requests. Increase this if the search index throttles a large run.

## Actor input object example

```json
{
  "queries": [
    "AI webinar",
    "cybersecurity conference"
  ],
  "startUrls": [
    {
      "url": "https://www.linkedin.com/events/7038508574142074880/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerQuery": 2,
  "market": "en-US",
  "requestDelayMillis": 1500
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in the event overview view.

# 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 = {
    "queries": [
        "AI webinar",
        "cybersecurity conference"
    ],
    "startUrls": [
        {
            "url": "https://www.linkedin.com/events/7038508574142074880/"
        }
    ],
    "maxItems": 20,
    "market": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/linkedin-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 = {
    "queries": [
        "AI webinar",
        "cybersecurity conference",
    ],
    "startUrls": [{ "url": "https://www.linkedin.com/events/7038508574142074880/" }],
    "maxItems": 20,
    "market": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/linkedin-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 '{
  "queries": [
    "AI webinar",
    "cybersecurity conference"
  ],
  "startUrls": [
    {
      "url": "https://www.linkedin.com/events/7038508574142074880/"
    }
  ],
  "maxItems": 20,
  "market": "en-US"
}' |
apify call automation-lab/linkedin-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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