# Facebook Events Scraper (`fetch_cat/facebook-events-scraper`) Actor

Export public Facebook event details and organizer event lists with dates, venues, hosts, ticket links, media, and engagement data to CSV, JSON, Excel, or API.

- **URL**: https://apify.com/fetch_cat/facebook-events-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, Marketing, Lead generation
- **Features:** Limited permissions
- **Stats:** 5 total users, 3 monthly users, 72.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.39 / 1,000 item extracteds

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/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

Extract public Facebook event details and organizer event lists into a dataset for CSV, JSON, Excel, or API use. Collect dates, venues, hosts, ticket links and available media without providing a Facebook login. Anonymous access varies by target.

### Quick start

Paste a public event URL or numeric event ID, choose a small `maxItems`, then run the Actor and open its dataset. For an older event, enable `includePastEvents`:

```json
{
  "eventIds": ["1855253805343101"],
  "maxItems": 1,
  "includePastEvents": true
}
```

This is an input recipe, not a guarantee that this event remains publicly accessible. Use an event you can view without signing in.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### Ready-to-run examples

Choose a public example to see its settings before starting a run:

- [Facebook Events API Example for Developers](https://apify.com/fetch_cat/facebook-events-scraper/examples/facebook-events-api-example)
- [Export Facebook Organizer Events Data](https://apify.com/fetch_cat/facebook-events-scraper/examples/export-facebook-organizer-events-data)
- [Facebook Events Scraper: Event Details](https://apify.com/fetch_cat/facebook-events-scraper/examples/scrape-facebook-event-details)

### What you get

Facebook Events Scraper collects public event pages and public organizer hosted-event lists. Use it to monitor event calendars, enrich lead lists, track local event activity, or build research datasets without manually opening every event page.

The Actor accepts direct Facebook event URLs, numeric event IDs, and organizer hosted-event URLs such as `facebook.com/{page}/upcoming_hosted_events`.

### Who is it for?

- Event marketers building outreach lists
- Local media and community researchers tracking upcoming events
- Tourism, venue, and entertainment teams monitoring public calendars
- Data teams enriching event IDs with names, dates, venues, hosts, and media
- Analysts who need repeatable exports instead of manual copy-paste work

### How you can use the data

- **Enrich a known public event ID.** Use the existing numeric-ID recipe with a one-event cap. Keep `eventId`, `name`, `url`, `startISO`, `timezone` and `scrapedAt` together, checking available dates and the source page before adding it to a calendar.
- **Review an organizer's public event list.** Supply its supported hosted-event URL with a small cap. Inspect host, venue and event links for your own editorial or research sheet. This is not keyword or city-based event discovery.
- **Research an older event explicitly.** Enable past events when using the existing older-event recipe. A past-list URL selects the organizer list, while older detail records still require the past-events setting.
- **Plan and import saved events.** Enable source-backed planning facts to check known frequency, event kind and child availability. Optionally export saved rows as an ICS calendar, selecting a date window without changing dataset rows, their order or charges. Separate going/interested counts remain unavailable.

### Input settings

| Setting / API key | Type | Required | Description |
| --- | --- | --- | --- |
| Facebook URLs / `startUrls` | array | Alternative | Direct event URLs or public page, profile or group event-list URLs. Search and shared links are unsupported. |
| Event IDs / `eventIds` | array | Alternative | Numeric Facebook event IDs. Supply URLs, IDs, or both. |
| Maximum events / `maxItems` | integer | No | Maximum saved event records across the run. Default 10. |
| Include past events / `includePastEvents` | boolean | No | Select past organizer lists and allow older detail records. Default `false`. |
| Planning facts / `includePlanningDetails` | boolean | No | Target-bound same-response facts. Default `false`. |
| Calendar file / `exportCalendar` | boolean | No | Export saved rows only. Default `false`. |
| Calendar selection / `calendarStart`, `calendarEnd` | string | No | Inclusive/exclusive UTC event-start boundaries; requires calendar export. |
| Calendar cancellations / `calendarIncludeCanceled` | boolean | No | Omitted means true; false excludes known cancellations from file only. Requires export when supplied. |

Provide at least one URL or event ID, with at most 100 combined targets. IDs must contain 5–30 digits.  `maxItems` accepts 1–10,000. URL strings and `{ "url": "..." }` objects are accepted. Remote URL lists are not supported. New inputs use direct public connections. Explicit connection settings are respected. The Actor does not switch to another route when your selected route is unavailable.

#### Optional planning briefs and calendar import

Both `includePlanningDetails` and `exportCalendar` default to `false` and work independently. Planning reads only the already fetched event HTML. It adds `planningDetails` and populates corresponding compatibility fields only when target-ID-bound facts are present. Known zero children differs from unknown children: `childCount:0` does not imply an exhausted child connection. `childInstancesComplete` is `null` without edges, `false` for partial/unconfirmed edges, and `true` only with explicit exhausted pagination and a matching known count. Children are descriptive source instances, **not** extra saved or billed rows. No recurrence rule is inferred.

```json
{
  "eventIds": ["1855253805343101"],
  "maxItems": 1,
  "includePastEvents": true,
  "includePlanningDetails": true,
  "exportCalendar": true,
  "calendarStart": "2026-08-01T00:00:00Z",
  "calendarEnd": "2026-09-01T00:00:00Z",
  "calendarIncludeCanceled": false
}
```

This is an input recipe, not a promise of ongoing target availability. `calendarStart` (inclusive) and `calendarEnd` (exclusive) select **event start instants**, not overlapping durations; omit them for all saved dates. They require calendar export and valid UTC timestamps. `calendarIncludeCanceled` is optional and means `true` when omitted; false excludes only explicitly canceled events from the file. Calendar selection never filters dataset rows, changes `maxItems`/past-event behavior, charges fewer items, or scans more targets.

With export enabled, download `EVENTS_CALENDAR` from the run's key-value store (or the calendar Output link) and import that `.ics` content into your calendar application. `CALENDAR_SUMMARY` reports included/omitted counts, missing/invalid ends, unknown cancellation and text truncation. These records do not exist with export off. The file uses stable source-ID UIDs, exact UTC instants, escaped UTF-8 text and explicit `STATUS:CANCELLED` for known cancellations. Unknown start dates are omitted, unknown/invalid end dates have no `DTEND`, and no duration, attendance status, free admission or recurrence is invented. Calendar applications may visually apply their own default duration to an event without an end.

Export is bounded to 16 MiB in saved-row order; additional rows remain in the dataset but are counted as artifact-limit omissions. Calendar descriptions are limited to 16,384 characters, names/locations to 4,096; truncation affects only the file. Import is a file handoff, not a subscription, update-monitoring service or write to a private calendar. No additional source requests or item charges are made. Small optional local serialization/storage costs remain part of the run. Existing CSV/Excel view columns and their order are unchanged; request JSON for the complete nested planning facts.

#### Example inputs

Use the Quick start input as a small first run. Adjust the fields described above for your own data.

### Output data

Each dataset item represents one Facebook event.

| Group | Fields |
| --- | --- |
| Identity and provenance | `type`, `discoveredVia`, `id`, `eventId`, `inputUrl`, `url`, `canonicalUrl`, `sourceUrl`, `sourceType`, `scrapedAt` |
| Core event details | `name`, `description`, `isOnline`, `isCanceled`, `isPast`, `eventType`, `privacyInfo` |
| Dates and times | `formattedDate`, `dateTimeSentence`, `timezone`, `startTimestamp`, `endTimestamp`, `startISO`, `endISO`, `startDate`, `endDate`, `utcStartDate`, `utcEndDate`, `startTime`, `duration`, `durationSeconds` |
| Venue and coordinates | `location`, `locationName`, `locationAddress`, `address`, `locationCity`, `locationCountry`, `locationLat`, `locationLng`, `latitude`, `longitude`, `onlineDetails` |
| Hosts and organizers | `hosts`, `organizators`, `organizedBy`, `hostName`, `hostUrl`, `hostId`, `hostType`, `hostPhotoUri`, `hostCount` |
| Media and links | `photo`, `photos`, `photoUri`, `photoUrl`, `imageUrl`, `imageUri`, `imageCaption`, `video`, `videoUrl`, `videoThumbnailUri`, `videoThumbnailUrl`, `coverVideo`, `ticketUrl`, `ticketsInfo`, `externalLinks` |
| Categories, series, and children | `categories`, `discoveryCategories`, `categoryLabel`, `categoryCount`, `parentEvent`, `parentEventId`, `siblingEvents`, `siblingEventIds`, `hasChildEvents`, `childEvents`, `eventFrequency` |
| Engagement and compatibility | `usersResponded`, `usersGoing`, `usersInterested`, `paidContent`, `isClassEvent`, `isLiveAudioRoom`, `isRemoteLearningClass`, `isRemoteLearningCourse`, `groupEventPinnedToFeatured`, `hasRecordingAvailable` |

Available fields depend on the public event. `usersResponded` is a combined count, not an attendee list. `usersGoing`, `usersInterested`, `privacyInfo`, `paidContent`, `isClassEvent`, `isLiveAudioRoom`, `isRemoteLearningClass`, `isRemoteLearningCourse`, `groupEventPinnedToFeatured` and `hasRecordingAvailable` remain `null`.

Default output is unchanged: `eventFrequency`, `eventType`, `hasChildEvents` and `imageCaption` remain `null`, `childEvents` stays empty, and `ticketsInfo` supplies only an available URL. With `includePlanningDetails:true`, source-bound facts may populate these fields, plus `planningDetails` containing frequency, kind, known child count, observed child instances/completeness, ticket context and caption. Null means absent or conflicting, never free/zero/unavailable. The verified public example exposes `SINGLE`, `PUBLIC_TYPE` and a known child count of zero; its ticket price/provider and caption are unknown. Ticket labels/provider/price and recurring child connections are supported only when those shapes are actually present; synthetic regression coverage is not proof of their availability on every live event. No recommendation nodes, attendee identities or private/login-only data are included.

Results follow input/discovery order, not chronological order. `startTime` repeats the formatted date text rather than an isolated clock time. Per-input outcomes and run totals are available in the `RUN_SUMMARY` key-value-store record. Diagnostic messages are not dataset rows.

#### More example output

Illustrative shape only. These sample values are not an observed event. Optional fields depend on what Facebook exposes publicly.

```json
{
  "type": "event",
  "eventId": "1855253805343101",
  "name": "Public event name",
  "url": "https://www.facebook.com/events/1855253805343101",
  "dateTimeSentence": "Sun, Aug 9 at 10:00 AM UTC+02",
  "utcStartDate": "2026-08-09T08:00:00.000Z",
  "hostName": "Event organizer",
  "locationName": "Venue name",
  "usersResponded": 123,
  "discoveredVia": "event",
  "scrapedAt": "2026-08-01T14:30:00.000Z"
}
```

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

The `start` event is charged once when startup capacity permits the run, including runs that ultimately save no events. The primary `item` event is charged for each Facebook event record saved to the dataset. Failed inputs that produce no dataset items do not create item charges.

Use a small item cap for an initial organizer-list sample. See the [live Pricing tab](https://apify.com/fetch_cat/facebook-events-scraper/pricing) for current rates and discounts.

### Tips for best results

- **Use supported event IDs or public event-list URLs.** Search and shared links are not supported starting inputs.
- **Start with a small global cap.** Organizer lists can contain several events, so inspect the initial output before increasing volume.
- **Set past-event handling deliberately.** The default is not a strict future-only filter, and older detail records need the explicit setting.
- **Inspect actual date fields before calendar use.** Source text and timezone coverage can vary, and `startTime` is formatted date text rather than an isolated clock time.
- **Read final status and per-input outcomes.** Check `RUN_SUMMARY` as well as saved records when a target is unavailable or work stops early.

### Limits and caveats

The default run has a 15-minute timeout and a shorter processing limit. Customer cost limits and short timeouts stop work successfully with a warning and `RUN_SUMMARY.limitStop`, preserving saved rows. Allow at least 103 seconds for useful work (up to three 30-second attempts plus retry and shutdown time); very short limits stop before extraction or explicit charges. Large inputs can stop before reaching the item cap. Start a new run rather than restarting or resurrecting one that already began processing.

- Only public Facebook surfaces are supported.
- Private events, login-only pages, missing events and blocked pages may not return data. An inaccessible response alone does not establish why a target is unavailable.
- Organizer list inputs are deduplicated by event ID before enrichment.
- `includePastEvents` selects past organizer lists and allows past details. An explicit `past_hosted_events` URL also selects a past list, but older detail records still require `includePastEvents: true`. With the default setting, events are filtered only when their end time (or start time if no end is known) is more than 24 hours old. This is not a strict future-only filter.
- Completed valid lists with no matches and events excluded as past succeed with an empty dataset and truthful reasons in the `RUN_SUMMARY` key-value-store record. An explicit Facebook age-restricted logged-out event route also succeeds without event rows; its source outcome is `event_unavailable_logged_out_age_restriction`. No login or restriction bypass is attempted.
- Parser failures, unverified blocked responses and unresolved extraction failures are not treated as legitimate emptiness. Any unresolved required extraction failure fails the run. Mixed batches preserve useful records and diagnostics.
- Essential storage, billing and processing-limit failures stop the run. Saved records may remain available in a failed run. Check the final run status as well as its dataset.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its `defaultDatasetId` to fetch the results.

For setup instructions, see Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~facebook-events-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "eventIds": [
    "1855253805343101"
  ],
  "maxItems": 1,
  "includePastEvents": true
}
JSON
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/facebook-events-scraper').call({
  "eventIds": [
    "1855253805343101"
  ],
  "maxItems": 1,
  "includePastEvents": true
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/facebook-events-scraper').call(run_input={'eventIds': ['1855253805343101'], 'maxItems': 1, 'includePastEvents': True})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP and AI agents

You can ask your AI assistant to collect data with **Facebook Events Scraper** and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the [Apify MCP server](https://mcp.apify.com/). MCP gives your assistant a way to find this scraper, run it and read the results. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp) for your app.

#### Easier setup with an Apify plugin

If you use a supported coding assistant, the [official Apify plugin](https://docs.apify.com/agents/plugins) can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

#### Use Apify AI in Console

Prefer to keep everything in Apify? Open [Apify AI in Console](https://docs.apify.com/account/apify-ai) and ask it to find Fetch Cat's **Facebook Events Scraper**. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

#### Choose your assistant

- **Claude and Claude Code (Anthropic):** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex (OpenAI):** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot (xAI):** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI (Google):** [MCP server setup guide](https://geminicli.com/docs/tools/mcp-server/). Use the server URL below with the HTTP configuration supported by Gemini CLI.

#### Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

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

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

#### Use Apify's general server

Already connected to the general Apify MCP server at `https://mcp.apify.com`? You can use it to find this scraper without adding another server. Ask your assistant to use **Facebook Events Scraper** by Fetch Cat, or give it the identifier `fetch_cat/facebook-events-scraper`.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

#### Example requests

- “Use Fetch Cat’s Facebook Events Scraper to retrieve one public event from the numeric ID I provide. Show its available name, source URL, start time and timezone so I can verify it before a calendar import.”
- “Collect up to 5 events from the public organizer hosted-events URL I provide. Include host names, venue information and source event links, then explain any unavailable targets or partial output.”
- “Retrieve the older public event ID I supply with past events enabled and a one-event cap. Show available dates and ticket links without inventing ticket prices or attendee information.”

Normal Apify charges apply. Check the [live Pricing tab](https://apify.com/fetch_cat/facebook-events-scraper/pricing) before asking your assistant to run a larger batch.

### Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through [x402](https://docs.apify.com/integrations/x402). This experimental option lets an agent use Apify without a conventional account.

[Apify AGI](https://agi.apify.com/) provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

#### Other ways for agents to pay

Apify also supports **MPP** for prepaid access through AGI and **Skyfire** for eligible Actors. If your agent already uses one of these, see the [agentic payment guide](https://docs.apify.com/agents/payments) to choose the right setup.

### FAQ

#### Can I export public Facebook events to CSV or JSON without logging in?

Yes. Provide public Facebook event URLs or public organizer event-list URLs, then export Facebook events data from the Apify dataset as CSV, JSON, Excel, Google Sheets, or via API.

#### Can I scrape Facebook organizer event lists through an API?

Yes. Use this Actor as a Facebook events API endpoint through Apify: send organizer URLs, set `maxItems`, and read normalized event records from the dataset.

#### Can it scrape private Facebook events?

No. The Actor is designed for public event pages and public organizer event lists only.

#### Why did my organizer URL return fewer events than expected?

Facebook may expose only a limited public list for anonymous visitors. The Actor saves available discovered events within `maxItems`, run budgets and charge capacity. Public lists may be incomplete even when more events are visible after login.

#### Can I scrape past events?

Yes. Set `includePastEvents` to `true` for direct event IDs or URLs, or to request an organizer's past-events list.

#### Does it support keyword search?

No. Supply event IDs or supported Facebook URLs. City discovery, keyword queries and search-result URLs are not supported.

#### How do I keep a test run cheap?

Use one direct `eventIds` value or one direct event URL with `maxItems: 1`.

### Related Actors

- [Facebook Pages Scraper](https://apify.com/fetch_cat/facebook-pages-scraper) — Collect public Page profile and contact fields, visible audience counts and optional post links.
- [Facebook Ads Library Scraper](https://apify.com/fetch_cat/facebook-ads-library-scraper) — Collect public Meta ad copy, advertiser details and available creative links for advertising research.
- [Facebook Posts Scraper](https://apify.com/fetch_cat/facebook-posts-scraper) — Collect visible public post text, publication dates and media from known Pages, groups or post URLs.
- [Eventbrite Events Scraper](https://apify.com/fetch_cat/eventbrite-events-scraper) — Collect public event URLs, dates, venues and available ticket-price information from Eventbrite.
- [Meetup Events Scraper](https://apify.com/fetch_cat/meetup-events-scraper) — Collect public event titles, dates, venues and available RSVP counts from Meetup targets or searches.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/facebook-events-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review](https://apify.com/fetch_cat/facebook-events-scraper/reviews) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

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

# Actor input Schema

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

Direct event URLs, public page/profile hosted-event URLs, or group event-list URLs. Supply URLs, eventIds, or both; at most 100 combined targets. Remote lists, share links, city discovery and keyword search URLs are unsupported.

## `eventIds` (type: `array`):

Optional numeric Facebook event IDs, each 5 to 30 digits. At most 100 combined IDs and URLs.

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

Maximum number of fully enriched event records to save.

## `includePlanningDetails` (type: `boolean`):

Read event-ID-bound frequency, public event kind, known child count/instances, ticket context and caption from the existing response. Missing/conflicting facts stay unknown. No additional requests or recurrence expansion; default rows stay unchanged when off.

## `exportCalendar` (type: `boolean`):

Create EVENTS_CALENDAR (RFC 5545 ICS) and CALENDAR_SUMMARY in this run's key-value store from saved dataset rows only. No extra event charges or requests. Up to 16 MiB; omissions and truncated text are reported. Does not change dataset rows or billing.

## `calendarStart` (type: `string`):

Optional start-time selection for the artifact only; requires exportCalendar. UTC ISO timestamp, e.g. 2026-08-01T00:00:00Z. No inferred local time zones.

## `calendarEnd` (type: `string`):

Optional exclusive event-start boundary for the artifact only; requires exportCalendar. Same UTC ISO format as calendarStart; must be later than calendarStart.

## `calendarIncludeCanceled` (type: `boolean`):

Optional; omitted means true. Requires exportCalendar when supplied. False excludes only explicitly canceled saved events from the artifact; unknown status is retained. Dataset rows and charges are unchanged.

## `includePastEvents` (type: `boolean`):

Select past organizer lists and allow older detail records, including direct event IDs. An explicit past_hosted_events URL selects a past list but still needs this setting to retain older details. When false, records are excluded only if their end time (or start time without an end) is more than 24 hours old; this is not a strict future-only filter.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/events/1855253805343101"
    },
    {
      "url": "https://www.facebook.com/SzigetFestival/upcoming_hosted_events"
    }
  ],
  "eventIds": [
    "1855253805343101"
  ],
  "maxItems": 10,
  "includePlanningDetails": false,
  "exportCalendar": false,
  "includePastEvents": false
}
```

# Actor output Schema

## `calendar` (type: `string`):

No description

## `calendarSummary` (type: `string`):

No description

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/events/1855253805343101"
        },
        {
            "url": "https://www.facebook.com/SzigetFestival/upcoming_hosted_events"
        }
    ],
    "eventIds": [
        "1855253805343101"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/facebook-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 = {
    "startUrls": [
        { "url": "https://www.facebook.com/events/1855253805343101" },
        { "url": "https://www.facebook.com/SzigetFestival/upcoming_hosted_events" },
    ],
    "eventIds": ["1855253805343101"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/facebook-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 '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/events/1855253805343101"
    },
    {
      "url": "https://www.facebook.com/SzigetFestival/upcoming_hosted_events"
    }
  ],
  "eventIds": [
    "1855253805343101"
  ]
}' |
apify call fetch_cat/facebook-events-scraper --silent --output-dataset

```

## MCP server setup

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