# Facebook Event Details & New-Event Monitor Scraper (`vexaloom-labs/facebook-event-details-and-new-event-monitor`) Actor

Fetch public Facebook event details by URL, page listing, or keyword/city search, with venue GPS, hosts, ticket links, and a monitor mode that reports only newly-posted events.

- **URL**: https://apify.com/vexaloom-labs/facebook-event-details-and-new-event-monitor.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 2 total users, 1 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

## Facebook Event Details & New-Event Monitor Scraper

Read public Facebook event pages, organizer event lists, and keyword search results without logging in. Get dates and time zones, venue and GPS when Facebook exposes them, hosts, ticket links and prices, recurring-series dates, and an optional only-new mode for scheduled runs.

### What this actor does

- **Event details by URL or ID:** name, description, start/end time, time zone, venue, coordinates, cover, hosts, creator, categories, tickets and online links.
- **Organizer Upcoming and Past:** read `/PageName/events`, `/PageName/upcoming_hosted_events`, or `/PageName/past_hosted_events`; page through the whole list up to your limit instead of stopping at the first batch.
- **Keyword search:** search Facebook's public events index and page through results. Optional date range, category, and location-ID filters (Facebook's place scope can include nearby cities).
- **Recurring series:** optionally add every occurrence date and URL for recurring events.
- **Monitor mode:** on a schedule, return only events not seen by an earlier run for the same organizer/search target. State is scoped to the Apify user who runs the actor, so separate users do not share history.
- **Durable images:** cover and host photos are copied into Apify storage; the original signed URL is kept beside the stored one.

Empty fields are omitted. The actor never fills a missing value with `null`, `0`, or a placeholder.

### Output per event

| Field | Description |
|---|---|
| `event_id`, `name`, `description`, `url` | Event identity and text. |
| `start_timestamp`, `end_timestamp` | Unix timestamps when the source provides them. |
| `start_date`, `end_date`, `formatted_date`, `timezone` | ISO dates, Facebook's own date sentence, and the event's time zone. |
| `is_online`, `is_canceled`, `is_past`, `is_sale_event` | Present when Facebook carries the flag. `is_canceled` is also inferred from a cancellation word in the event name when the flag is absent. |
| `event_kind`, `rsvp_style`, `event_frequency` | Visibility, RSVP style, recurring-series frequency. |
| `has_child_events`, `child_events_count` | Recurrence signals. |
| `occurrences[]` | When enabled: `{event_id,url,start_timestamp,end_timestamp,start_date,end_date}` for every series date. |
| `parent_event_id` | Present when the returned event is one occurrence of a series. |
| `location_name`, `location_address`, `location_city`, `location_city_id` | Venue text and city identifiers when exposed. |
| `one_line_address` | Facebook's normalized full address when available. |
| `latitude`, `longitude` | Venue GPS when the venue exposes coordinates. |
| `venue_place_id`, `venue_place_type`, `venue_url`, `venue_is_user_specified_location` | Venue metadata. |
| `photo_url`, `photo_url_original`, `photo_width`, `photo_height`, `photo_caption` | Stored cover image, its original signed URL, and dimensions/caption. |
| `video_url`, `video_url_original` | Cover video and original URL when downloadable; the original is retained if it is too large to rehost. |
| `hosts[]` | `{id,name,url,type,is_verified,profile_picture_url,profile_picture_url_original}`. |
| `creator` | `{id,name,type}` when Facebook exposes the creator. |
| `categories[]`, `category_urls[]` | Host-set categories and Facebook's category search links. |
| `ticket_url`, `ticket_provider`, `ticket_price_text` | Ticket link, provider, and the price text Facebook shows. Structured price tiers are not public. |
| `description_links[]` | External links Facebook recognized in the description. |
| `online_type`, `online_url` | Online-event type and registration/live link when shown. |
| `duration` | Facebook's duration text (e.g. `2 hr`). |
| `users_responded` | Combined response count; omitted when Facebook does not expose it. |
| `source_type` | `event_url`, `page_events`, `search`, or `occurrence`. |
| `input_url`, `scraped_at` | The target that produced the row and collection time. |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `eventUrls` | string list | – | Event URLs or IDs, organizer event pages, or an events search URL. The prefill contains one example event. |
| `searchQueries` | string list | – | Keywords for event search. |
| `searchLocation` | string | – | City/place text added to each query. This is a relevance hint, not a strict filter. |
| `locationId` | string | – | Numeric Facebook place ID or `/places/<id>/` URL for a location filter. Facebook's place scope can include nearby cities. |
| `startDate`, `endDate` | string | – | `YYYY-MM-DD` search range. |
| `category` | select | Any | One of Facebook's event categories. |
| `includePastEvents` | boolean | false | Organizer pages: read Past instead of Upcoming. |
| `includeOccurrences` | boolean | false | Add every date of a recurring series. |
| `maxItems` | integer | 50 | Per organizer listing or search query (1–1000). |
| `monitorMode` | boolean | false | Only events not seen by a previous run for the same target. |

#### Examples

```json
{
  "eventUrls": ["https://www.facebook.com/events/1855253805343101"],
  "includeOccurrences": true
}
```

```json
{
  "eventUrls": ["https://www.facebook.com/TED/upcoming_hosted_events"],
  "maxItems": 100,
  "monitorMode": true
}
```

```json
{
  "searchQueries": ["food festival"],
  "searchLocation": "Chicago",
  "startDate": "2026-11-01",
  "endDate": "2026-11-30",
  "category": "Food",
  "maxItems": 100
}
```

### Use cases

- Build a local what's-on calendar from venues and organizers.
- Watch an organizer's page on a schedule and report only newly posted events.
- Collect dates, venues, ticket links and host details for event directories.
- Research recurring series across a city or category.
- Map events that expose coordinates.

### FAQ

**Do I need a Facebook login or cookies?** No. The actor reads only public pages. Group events, private events, and city-name typeahead require login and are not supported.

**Why is a venue address or GPS missing?** Many Facebook events use free-text locations without coordinates. The actor returns what the event exposes and omits the rest; it never geocodes or invents a location.

**Why did a search return fewer results than I asked for?** Facebook's public search index is relevance-ranked and changes between requests; categories are host-set and often empty. The actor retries a throttled first page and logs a warning when pagination stops short of your limit. Facebook can also end a deep result set early without an error; that can look like exhaustion, so a shortfall is not always flagged. It never fabricates rows to fill the gap.

**How does monitor mode decide what is new?** It stores the event IDs already reported for each organizer/search target in an Apify key-value store. State is scoped to the Apify user who runs the actor, so separate users do not share history for the same target. Runs without a user identity use a stable anonymous scope. The first run is a baseline; later runs omit seen IDs. Clearing the store, changing the target, or losing state causes a new baseline. There is no webhook; schedule the actor and read the dataset. Concurrent runs can race.

**Can I get every date of a recurring event?** Yes when the event exposes child occurrences. Turn on `includeOccurrences`; the record gets an `occurrences[]` list. A one-off event has no list.

**Can I filter by city?** Use `locationId` with a numeric Facebook place ID or `/places/<id>/` URL. Facebook's place scope can include nearby cities, so treat it as best-effort, not an exact city boundary. Facebook's city text lookup needs login, so `searchLocation` is a keyword hint only.

**Can I get attendee lists or separate going/interested counts?** No. Facebook restricts attendee identities, and it no longer exposes separate going/interested figures to logged-out visitors. `users_responded` is the combined public count; there is no separate `interested` field.

**Do group events work?** No. Facebook Groups require a logged-in session, so group event URLs are skipped with a warning.

**Are images permanent?** Cover and host images are copied into Apify storage and the original signed URL is kept in `*_original`. Facebook CDN originals expire after a few days.

**Is this affiliated with Facebook or Meta?** No. This is an independent tool and is not affiliated with, endorsed by, or sponsored by Meta Platforms, Inc.

### Limits

- No group events, private events, guest lists, or split going/interested counts.
- No true radius/nearby search; a location filter needs a Facebook place ID, and its scope can include nearby cities.
- GPS and street addresses are conditional on what the venue exposes.
- Ticket price is text only; structured price tiers are not public.
- Search results are dynamic; a retry can still return fewer rows than requested.

# Actor input Schema

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

Facebook event URLs or IDs, organizer event pages (e.g. https://www.facebook.com/TED/events, /upcoming_hosted_events, /past_hosted_events), or an events search URL. Group event URLs are skipped because they require login.

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

Keywords for Facebook's public events search (e.g. "music festival", "tech conference"). Each query is paginated up to Max results.

## `searchLocation` (type: `string`):

City or place text added to each search query (e.g. "Chicago"). This is a keyword hint, not a strict geographic filter; use Location ID for a strict filter.

## `locationId` (type: `string`):

Optional Facebook place ID or /places/<id>/ URL for a location filter on search. Facebook's place scope can include nearby cities. Text-to-ID lookup requires login, which this actor does not use.

## `startDate` (type: `string`):

Optional search filter lower bound in YYYY-MM-DD format (e.g. 2026-12-01). Applies to search queries only.

## `endDate` (type: `string`):

Optional search filter upper bound in YYYY-MM-DD format. Equal to Start date selects one day.

## `category` (type: `string`):

Optional server-side category filter for search queries. Categories are host-set, so some events have none.

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

For organizer pages, fetch the Past collection instead of Upcoming. Ignored for event URLs and search.

## `includeOccurrences` (type: `boolean`):

For recurring events, add every occurrence date and URL to the event record. Uses one extra request only when the event is recurring.

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

Maximum events per organizer listing or search query. A direct event URL always returns its one event.

## `monitorMode` (type: `boolean`):

For organizer pages and searches, output only events not seen by an earlier run for the same target. The first run is a baseline. State is a named Apify store, is actor-wide (not per user), and is shared by all runs of this actor for the same target; clearing it or changing the target re-emits all events.

## Actor input object example

```json
{
  "eventUrls": [
    "https://www.facebook.com/events/1855253805343101"
  ],
  "category": "Any",
  "includePastEvents": false,
  "includeOccurrences": false,
  "maxItems": 50,
  "monitorMode": false
}
```

# Actor output Schema

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

Dataset containing all scraped Facebook 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 = {
    "eventUrls": [
        "https://www.facebook.com/events/1855253805343101"
    ],
    "includePastEvents": false,
    "includeOccurrences": false,
    "maxItems": 50,
    "monitorMode": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/facebook-event-details-and-new-event-monitor").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 = {
    "eventUrls": ["https://www.facebook.com/events/1855253805343101"],
    "includePastEvents": False,
    "includeOccurrences": False,
    "maxItems": 50,
    "monitorMode": False,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/facebook-event-details-and-new-event-monitor").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 '{
  "eventUrls": [
    "https://www.facebook.com/events/1855253805343101"
  ],
  "includePastEvents": false,
  "includeOccurrences": false,
  "maxItems": 50,
  "monitorMode": false
}' |
apify call vexaloom-labs/facebook-event-details-and-new-event-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/facebook-event-details-and-new-event-monitor"
        }
    }
}
```

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/xSp7vACk0FpUckkaH/builds/k2U4MYmHDAlszwlFn/openapi.json