# Facebook Page Events Scraper — Dates, Venue, Tickets, No Login (`foxlabs/facebook-page-events-scraper`) Actor

Events of public Facebook Pages, or single events by address: name, start and end, place with city and coordinates, online or in person, canceled, host, description, ticket address, cover. Many Pages a run, each event's own page read for the details. No login.

- **URL**: https://apify.com/foxlabs/facebook-page-events-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 events

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?

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

## Facebook Page Events Scraper — Dates, Venue, Tickets, No Login 🚀

**foXLabs Facebook series:** [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper) · [Page Profile](https://apify.com/foxlabs/facebook-page-profile-scraper) · [Post Comments](https://apify.com/foxlabs/facebook-post-comments-scraper) · [Page Reviews](https://apify.com/foxlabs/facebook-page-reviews-scraper) · [Page Videos](https://apify.com/foxlabs/facebook-page-videos-scraper)

🎉 Events of public Facebook Pages — and single events by address — exactly as Facebook shows them to a signed-out visitor: **name, exact start and end, place with city and coordinates, online or in person, past or upcoming, canceled, host, description, ticket address, cover**. Many Pages a run; each event's own page is read for the details. No login, no cookies, no account of anyone.

### 🔍 What is the Facebook Page Events Scraper — and when should you use it?

Give this Actor public Facebook Pages (or event addresses) and it returns their events as clean rows — exact times, venue with coordinates, host, description and ticket link.

**Use it when you need:** a Page's upcoming or past events as structured data; event listings with venue + coordinates for a calendar or map; or ticket links for an events aggregator.

**Use something else when:** you need the Page's posts → [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper); its contact record → [Page Profile](https://apify.com/foxlabs/facebook-page-profile-scraper).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/facebook-page-events-scraper`. An agent can discover it, run it and read the dataset over MCP.

**Real-time Standby API.** This Actor ships a Standby endpoint so an agent can fetch events on demand — `GET /events?page=NASA&maxEvents=8` for a Page, `GET /events?event=1474625497812411` for one event, billed with the same `event` event.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want public Facebook Page events using the Apify Actor
`foxlabs/facebook-page-events-scraper`.

Input: `pages` is a list of Pages (their events tab is read); `events` is a list of single event
URLs/ids; `withDetails` reads each event's page for exact times/place/tickets; `upcomingOnly`
keeps future events. Each row has name, startsAt, placeName, city, latitude, longitude, ticketUrl.

Start with:
{ "pages": ["NASA"], "withDetails": true }

Ask me which Pages or events I want, run the Actor, then summarise them as a calendar.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/facebook-page-events-scraper.md`.

### 📋 Overview

Everything you need to turn public Facebook Page events into clean, structured data — exact times, venue with coordinates, host and tickets — in one Actor, with no login, cookies or account.

**Why teams pick this Actor:**

- ✅ **Exact times + venue** — start/end with timezone, place name, city, address and coordinates.
- 🎟️ **Tickets & cover** — the ticket link and the cover image per event.
- 🔁 **Recurring events handled** — a series plus each of its dates, linked by `parentEventId`, no id delivered twice.
- 🎯 **Honest nulls** — a value Facebook does not give is `null`, never `0`/`""`.
- 💰 **Pay only for results** — one `event` event per row; status rows and unreadable Pages free.
- 🤖 **Agent-ready** — MCP + a real-time Standby API.

### ✨ Features

- 🔍 **Page events or single events** — a Page's events tab, or specific event URLs/ids.
- 🗓️ **Full event** — name, description, exact start/end + timezone, online/in-person, past/upcoming, canceled.
- 📍 **Venue** — place name, id, city, address, latitude, longitude.
- 👤 **Host + tickets** — host name/URL, ticket URL, cover image.
- 🧹 **Filter** — `upcomingOnly`.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~facebook-page-events-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pages": ["NASA"], "withDetails": true}'
```

### 🚀 Getting Started (3 steps)

1. **Choose Pages or events** — `pages` (name/@handle/id/URL) and/or `events` (event URL/id).
2. **Pick depth** — keep `withDetails` on for exact times/place/tickets; set `upcomingOnly` if you want.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

| Field | Default | What it does |
|---|---|---|
| `pages` | — | One Page per line. Its events tab is read: upcoming when it has any, past otherwise (how Facebook shows it). |
| `events` | — | One event per line: its URL or numeric id. |
| `maxEventsPerPage` | 50 | Events to deliver per Page. |
| `maxEvents` | 10000 | Rows in the whole run. |
| `withDetails` | true | Read each event's own page for exact times, place, description, tickets, cover. |
| `upcomingOnly` | false | Keep only events that have not started yet. |
| `proxyConfiguration` | residential Apify Proxy | Nothing to change for normal use. |

### 📤 Output

One row per event (`type: "event"`). A value Facebook does not give is `null`.

| Field | What it is |
|---|---|
| `eventId`, `url` | the event's id and address |
| `name`, `description` | name and description (from the event's page) |
| `startsAt`, `endsAt`, `timezone`, `timeText` | start/end (UTC), timezone, and Facebook's sentence |
| `isOnline`, `isPast`, `isCanceled`, `kind` | online/in-person, over, canceled, Facebook's kind |
| `placeName`, `placeId`, `city`, `address`, `latitude`, `longitude` | where |
| `hostName`, `hostUrl`, `hostId`, `pageId` | host and the Page's id |
| `ticketUrl`, `coverUrl` | tickets and cover |
| `parentEventId` | the series a recurring date belongs to |
| `detailsRead` | whether the event's own page was read |
| `position`, `input`, `type`, `error` | place in the list; input line; row type / free status row |

```json
{
  "type": "event",
  "eventId": "1474625497812411",
  "url": "https://www.facebook.com/events/1474625497812411/",
  "name": "MAX POWER",
  "startsAt": "2026-11-07T13:30:00.000Z",
  "endsAt": "2026-11-08T23:00:00.000Z",
  "timeText": "Nov 7 at 8:30 AM – Nov 8 at 6:00 PM EST",
  "isOnline": false,
  "isPast": false,
  "placeName": "NASA-John F. Kennedy Space Center",
  "hostName": "NASA - National Aeronautics and Space Administration",
  "description": "MAX POWER is a new aerospace tech expo and air show…",
  "ticketUrl": "https://…",
  "detailsRead": true,
  "position": 1,
  "input": "NASA"
}
```

### 💼 Use cases

**1. Events calendar / aggregator** — pull many Pages' events with exact times and venues.
*Input:* your Pages, `withDetails` on. *Output:* events + place + coordinates. *Use:* populate a calendar or map.

**2. Ticketing & promotion leads** — events with ticket links for outreach.
*Input:* venue/promoter Pages, `upcomingOnly`. *Output:* upcoming events + `ticketUrl`. *Use:* a promotion pipeline.

**3. Competitor event tracking** — watch what events a rival runs.
*Input:* competitor Pages, scheduled. *Output:* their events over time. *Use:* benchmark their activity.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/facebook-page-events-scraper').call({
  pages: ['NASA'], withDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/facebook-page-events-scraper').call(
    run_input={'pages': ['NASA'], 'withDetails': True}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the Actor API with your `pages`/`events` → handle the JSON dataset → push to a sheet, calendar or dashboard.

### 📊 Pricing

Pay per event: **`event`** for every delivered event row — whatever it carries. The price is on the Pricing tab. Nothing else is charged: no start fee, nothing for a status row, nothing for an event the filter left out, nothing extra for reading the event's own page.

### ❓ FAQ

**Can I get both upcoming and past events?** No — Facebook shows a visitor one collection: upcoming when the Page has any, otherwise past. (Single events by id are always readable.)

**Do I get exact start times?** With `withDetails` on, yes (`startsAt`/`endsAt` + timezone). Without it, only Facebook's date sentence (`timeText`).

**How are recurring events handled?** As the series plus each date, linked by `parentEventId`; no id is delivered twice.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

**What about guest lists / attendance?** Not shown to a visitor, so not in the rows.

### 🐛 Troubleshooting

- **Only past (or only upcoming) events** — the events tab shows a visitor one collection; that's Facebook's behaviour, not a bug.
- **No timestamps** — turn on `withDetails`; the tab alone has only the date sentence.
- **A Page returns a status row** — no events tab, no such Page, or signed-in only (free).
- **A recurring event appears twice** — it shouldn't: a series + its dates are distinct ids linked by `parentEventId`.

**How it reads Facebook:** opens the events tab as a signed-out visitor (eight events) and asks Facebook's list query for the rest (eight a call); with `withDetails` it opens each event's own page for times/place/tickets. Residential Apify Proxy by default; rate-limited exits dropped and replaced. Every run starts with a one-call check and ends with a clear message if Facebook's queries changed.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to Meta Platforms, Inc. "Facebook" and related marks belong to their owners and are used here for identification only.

### ⚖️ Is it legal to scrape this data?

It reads only what Facebook shows a signed-out visitor, about public events of Pages — no guest lists, no attendees. The Actor does not log in, use anyone's account or cookies, or solve CAPTCHAs. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab — include the run id; the run's `SOURCE_REPORT` record holds what was asked and why the run stopped.
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.2 — 2026-10-11 — the shared core of the family

- The shared core was updated with the Page Reviews Actor; event rows are unchanged.

#### 0.1.1 — 2026-10-11 — recurring events

- A recurring event is listed as its series and as each of its dates; a row keeps the id and address it was listed under, and a date names its series in `parentEventId` (fixing a date delivered twice).

#### 0.1.0 — 2026-10-11 — first release

- Events of public Facebook Pages as a signed-out visitor sees them — upcoming when the Page has any, past otherwise, eight in the tab and eight a call after — and single events by address.
- With `withDetails` each event's page is read: exact start/end + timezone, online/in-person, past/upcoming, canceled, place (id, city, address, coordinates), description, tickets, cover. Without it: name, date sentence, place, host.
- `upcomingOnly` leaves past events out without charging. Free status rows for empty lines; restarted runs continue without duplicates. Standby mode prepared; published in batch mode.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/facebook-page-events-scraper/changelog.md

# Actor input Schema

## `pages` (type: `array`):

One Page per line: a name (NASA), @NASA, a numeric id, or an address (https://www.facebook.com/NASA). The Page's events tab is read — upcoming events when it has any, past ones otherwise, as Facebook shows it. Leave empty to read single events only.

## `events` (type: `array`):

One event per line: its address (https://www.facebook.com/events/1474625497812411/) or its numeric id. Read directly from the event's own page.

## `maxEventsPerPage` (type: `integer`):

How many events to deliver for each Page. Facebook hands the tab out eight events at a time.

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

The run stops when this many rows have been delivered. You are charged only for delivered rows.

## `withDetails` (type: `boolean`):

One page per event: exact start and end, time zone, online or in person, past or upcoming, canceled, place with coordinates, description, ticket address, cover. Off: only what the Page's events tab shows (name, date sentence, place name and city, host, address) — one page per eight events.

## `upcomingOnly` (type: `boolean`):

Deliver only events that have not started yet. Events already over are left out without being charged.

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

Nothing to change for normal use: the Actor reads Facebook through Apify Proxy residential addresses, the only kind Facebook serves its public Pages to (measured: residential 25 of 25 requests, datacenter 0 — sent to the login page). Set a proxy here to send every request through it instead.

## Actor input object example

```json
{
  "pages": [
    "NASA",
    "metmuseum"
  ],
  "maxEventsPerPage": 10,
  "maxEvents": 10000,
  "withDetails": true,
  "upcomingOnly": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "pages": [
        "NASA",
        "metmuseum"
    ],
    "maxEventsPerPage": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/facebook-page-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 = {
    "pages": [
        "NASA",
        "metmuseum",
    ],
    "maxEventsPerPage": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/facebook-page-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 '{
  "pages": [
    "NASA",
    "metmuseum"
  ],
  "maxEventsPerPage": 10
}' |
apify call foxlabs/facebook-page-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/facebook-page-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/24kpeKQILMZdHhtAF/builds/Lb0q4yMWcXs0Curke/openapi.json