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

Find LinkedIn events without a LinkedIn account. Search any topic — conferences, summits, webinars — and get a clean list of public events (name, URL, ID) as JSON or CSV. Zero cookies, zero login, zero account risk. Perfect for event research, lead generation, and market intelligence.

- **URL**: https://apify.com/memo23/linkedin-events-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 20 total users, 20 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $30.00 / 1,000 event 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/actors/running/actors-in-store.md#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 — No Cookies, No Login

Discover **public LinkedIn Events** by keyword or direct URL — with **no login and no cookies**. The actor finds publicly-indexed LinkedIn event pages and returns one clean row per event: name, URL, and id. Output as JSON or CSV.

### Why use this actor

- **Zero setup** — no LinkedIn account, no session cookie, no expiry headaches.
- **No account risk** — it never touches your LinkedIn login.
- **Find events by topic** — search any keyword ("AI conference 2026", "marketing summit", "product webinar").
- **Include specific events** — paste event URLs you already have.
- **Never fails silently** — an empty result set yields a structured sentinel record, so scheduled runs stay green.

### How it works

- For each keyword, the actor runs a `site:linkedin.com/events {keyword}` search and parses the LinkedIn event links out of the results.
- **Discovery source** (`publicSearchProvider`):
  - `direct` *(default)* — fetches Google results through **Apify's Google SERP proxy**. Fully cookieless, no extra actor fee.
  - `apify-google` — calls the `apify/google-search-scraper` actor. Requires the "run public Actors" feature on your Apify plan.
- Direct event URLs you supply are emitted with the id and a slug-derived name.

> **Coverage note:** LinkedIn event pages are login-walled, so search engines index relatively few of them. Expect a **modest number of events per keyword** — this actor surfaces what is publicly discoverable, not LinkedIn's full internal event catalog. Use several targeted keywords for broader coverage.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `searchQueries` | Array | Yes\* | Keywords to discover events for |
| `eventUrls` | Array | Yes\* | Direct LinkedIn Event URLs to include |
| `publicSearchProvider` | Enum | No | `direct` (default) / `apify-google` |
| `maxItems` | Integer | No | Max events per run (default 50, max 1000) |
| `proxy` | Object | No | Proxy configuration (Apify Proxy recommended) |

\* Provide at least one of `searchQueries` or `eventUrls`.

#### Example input

```json
{
  "searchQueries": ["AI conference 2026", "marketing summit"],
  "eventUrls": ["https://www.linkedin.com/events/7180400221846138880/"],
  "publicSearchProvider": "direct",
  "maxItems": 50,
  "proxy": { "useApifyProxy": true }
}
```

### Output

Each discovered event is one dataset row:

| Field | Type | Description |
|---|---|---|
| `eventName` | String | Event name (from the search result, or derived from the URL slug) |
| `eventUrl` | String | Canonical LinkedIn event URL |
| `eventId` | String | Numeric event id |
| `snippet` | String | Short description snippet, when the search result provides one |
| `source` | String | Always `public-search` |
| `scrapedAt` | String | ISO 8601 timestamp |

Fields are omit-empty: only fields with real values appear.

#### Sample output

```json
{
  "eventName": "AI Innovation Summit",
  "eventUrl": "https://www.linkedin.com/events/7029930418099404800/",
  "eventId": "7029930418099404800",
  "source": "public-search",
  "scrapedAt": "2026-07-13T20:16:27.000Z"
}
```

#### Sentinel records

When a run finds nothing, the actor emits a structured record instead of failing:

```json
{
  "_status": "no_data",
  "_reason": "no-results",
  "_message": "No public events found for these queries via search-engine discovery.",
  "scrapedAt": "2026-07-13T20:16:27.000Z"
}
```

### FAQ

**Do I need a LinkedIn account or cookie?** No. This actor uses only publicly-indexed data — no login, ever.

**Why did I only get a few events?** LinkedIn event pages are behind a login wall, so search engines index a limited subset. Use multiple targeted keywords to widen coverage.

**What does `apify-google` need?** The "run public Actors" feature on your Apify plan. If it's not enabled, keep the default `direct` provider, which needs nothing extra.

**Can I scrape attendee lists / private events?** No — those require an authenticated LinkedIn session, which this actor deliberately does not use.

### ⚠️ Disclaimer

This actor collects only publicly available, search-engine-indexed information about LinkedIn events. You are responsible for using it in compliance with LinkedIn's Terms of Service, applicable laws (including data-protection regulations such as GDPR/CCPA), and any contractual obligations. Do not use the output to spam, harass, or otherwise harm individuals. The authors provide this tool "as is" without warranty and accept no liability for misuse.

### SEO Keywords

LinkedIn Events scraper, LinkedIn events without login, cookieless LinkedIn scraper, scrape LinkedIn events by keyword, LinkedIn event URL scraper, LinkedIn conference scraper, LinkedIn webinar finder, public LinkedIn events, event discovery tool, LinkedIn events export CSV JSON, no-cookie LinkedIn events, Apify LinkedIn events.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to discover public LinkedIn Events for. One keyword per line (e.g. "AI conference 2026", "marketing summit", "product management webinar").

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

Direct LinkedIn Event URLs to include, e.g. https://www.linkedin.com/events/7180400221846138880/. One URL per line. Can be combined with search queries.

## `publicSearchProvider` (type: `string`):

'Google SERP proxy' (recommended) fetches Google results through Apify's Google SERP proxy — fully cookieless, no extra actor fee. 'Apify Google Search Scraper' calls the apify/google-search-scraper actor, which requires the "run public Actors" feature enabled on your Apify plan.

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

Maximum number of events to collect per run. The actor stops once it reaches this number.

## `proxy` (type: `object`):

Proxy servers used by the scraper. Apify Proxy is recommended.

## Actor input object example

```json
{
  "searchQueries": [
    "AI conference"
  ],
  "eventUrls": [],
  "publicSearchProvider": "direct",
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQueries": [
        "AI conference"
    ],
    "eventUrls": [],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "searchQueries": ["AI conference"],
    "eventUrls": [],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/linkedin-events-scraper").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 '{
  "searchQueries": [
    "AI conference"
  ],
  "eventUrls": [],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call memo23/linkedin-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/linkedin-events-scraper"
        }
    }
}

```

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/ofiXoDylzC336IUJ8/builds/lXqSekF3TbAT2UCdr/openapi.json