# Facebook Events Scraper - Dates, Venues & Ticket Links (`s-r/facebook-events`) Actor

Collect public Facebook events from pages, event URLs and limited text searches. Export dates, venues, coordinates, organizers, ticket links and public attendance counts.

- **URL**: https://apify.com/s-r/facebook-events.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Social media, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$6.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?

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 Events Scraper

Facebook Events Scraper collects public events from Facebook pages and individual event URLs. Export dates, venues, coordinates, organizers, ticket links and public attendance information as one row per event.

Use the results to maintain a venue calendar, follow a promoter's announcements, compare local event listings or prepare an event directory. A stable Facebook event ID helps you match repeat exports and update an existing record when its date or venue changes. Only public information available without a Facebook account is collected.

### Facebook Events Scraper input

Provide `start_urls` with public Facebook page handles, page URLs or individual event URLs. The MOJO page used in the included examples is `https://www.facebook.com/mojoconcerts`. A direct event example is `https://www.facebook.com/events/1377830703495746/`, the public Treasure concert at AFAS Live in Amsterdam. Long event URLs containing a venue and event name are also accepted and resolve to the same event ID.

```json
{
  "start_urls": ["https://www.facebook.com/mojoconcerts"],
  "event_type": "upcoming",
  "max_events": 25,
  "include_details": true
}
```

Choose `event_type` as `upcoming`, `past` or `both` for page inputs. A URL ending in `upcoming_hosted_events` or `past_hosted_events` explicitly selects that tab and takes precedence over the general setting. The limit `max_events` defaults to 50 and accepts values from 1 to 1,000 per input. With `both`, that limit is shared across the two tabs. Events repeated between inputs are delivered once.

Set `include_details` to `false` for a lighter list export. List records contain the event ID, title, URL and the date, venue and organizer fields that Facebook provides in that list. They do not include the complete address, coordinates, description or ticket link. Search lists can omit dates entirely. Individual event URLs always return the event details, regardless of this setting.

### Text searches and city overviews

Use `search_queries` for a text query such as `techno`. This is a limited discovery option: Facebook exposes about 20 events per query without login, and the results cannot be restricted reliably to a requested city. Adding a city to the query does not guarantee results from that city. Each search response includes a warning explaining this limit. This actor does not promise complete geographic search coverage.

A public city overview URL is another supported input. The captured Amsterdam example is `https://www.facebook.com/events/explore/amsterdam-netherlands/111777152182368/`. These overviews typically expose about 12 events and have no further pages. For a complete calendar of a known organizer, use its page's hosted events instead. You can combine up to 20 page, event, city overview and text search inputs in one run.

### Output and event fields

The default dataset contains one row per unique public event. The shared event fields include `event_id`, `title`, `url`, `start`, `start_date`, `end`, `venue_name`, `address`, `city`, `country_code`, `lat`, `lng`, `organizer_name` and `category`. Each record also identifies its source, platform and collection time through `source`, `platform` and `fetched_at`.

Detailed records add `ticket_url`, `description`, organizer IDs and URLs, all public `hosts`, the cover image, cancellation and past-event flags, and available attendance fields. `source_input` identifies the input that produced the record, while `source_page` identifies a page handle when applicable. `detail_level` distinguishes a list record from an enriched event record.

A recurring event's parent URL returns one record under that parent ID. Dates and details describe the occurrence currently shown by Facebook; `child_events_count` describes the series. An individual occurrence URL keeps its own event ID and its `parent_event_id`. If a listed event's details remain unavailable after a retry, the list record is retained with `detail_level: "list"` and a warning.

Missing information is returned as `null`. Facebook does not provide ticket prices or ticket availability through these public event pages, so price and sale-status fields remain null. A ticket link alone does not establish that tickets are available. Local `start` and `end` values use the UTC offset Facebook provides. `start_utc` preserves the absolute time when available. An IANA timezone is not inferred; `timezone` remains null. List-only records have no reliable local offset and therefore leave the local time fields null.

Attendance needs careful interpretation. `responded_count` is the exact public response total when Facebook provides it. `interested_display` and `going_display` preserve the displayed text. If Facebook shows `1.1K` interested people, `interested_count` remains null because the text is rounded. An unrounded value such as `124` can populate `going_count`. Counts are not calculated by subtracting one public counter from another.

The run's OUTPUT record includes events, warnings, input-specific errors, status information and continuation metadata. Source collection totals describe what Facebook reports; they can differ from the number of events actually accessible. They are not a promise of a particular result count.

### Pricing and free results

The configured price is $6 per 1,000 delivered events, subject to the current pricing shown on the actor's Pricing tab. The same event is charged once when delivered, including when it is encountered through multiple inputs. Empty results and events that could not be delivered are not charged. There is no separate event-detail charge or start fee in this product's charge configuration.

Non-paying users receive up to 10 event records per run. Larger collections are continued automatically for paying users until the requested limits, available public results or run budget are reached. A partial run includes warnings so you can distinguish a complete source result from an interrupted collection.

### FAQ

#### Do I need a Facebook account or cookies?

No. This actor collects only publicly accessible event information. It does not accept login credentials, access private events or expose guest lists. A private, removed or unknown event can return a not-found result.

#### Why does a venue page have no upcoming events?

Facebook's hosted event tab contains events created or hosted by that page. Concerts taking place at a venue may be hosted by promoters instead. Try the promoter's page or supply known event URLs. An existing page with no matching hosted events does not produce fabricated event rows.

#### Can I collect every event in a city?

No. Text searches and city overviews have the limits described above. For dependable coverage, maintain a list of relevant organizer pages and collect their upcoming hosted events. Public availability can also change between runs.

#### Can I resume a large API request?

Yes. API responses include `next_cursor` when another request is needed. Repeat the original input with that cursor and combine the returned event rows. The Apify actor follows continuation automatically, so ordinary actor users do not need to manage cursors themselves.

# Actor input Schema

## `start_urls` (type: `array`):

Public Facebook page handles or URLs, event URLs (including slug URLs), search URLs or city overview URLs. At most 20 inputs combined with search_queries.

## `search_queries` (type: `array`):

Best effort event text searches. Facebook returns about 20 events per query without login and cannot guarantee a city or location.

## `event_type` (type: `string`):

Hosted events to collect from pages. Explicit upcoming_hosted_events or past_hosted_events URLs take precedence. Both shares max_events across the two tabs.

## `max_events` (type: `integer`):

Maximum unique events per start URL or search query, across all cursor requests. Default 50. Events shared between inputs are delivered only once.

## `include_details` (type: `boolean`):

Fetch event pages for local times, address, coordinates, hosts, ticket URL and attendance. False returns list fields; direct event URLs always return details.

## `cursor` (type: `string`):

Opaque next_cursor from the previous response. Repeat all other input fields unchanged. Apify follows this automatically.

## Actor input object example

```json
{
  "start_urls": [
    "https://www.facebook.com/mojoconcerts"
  ],
  "event_type": "upcoming",
  "max_events": 50,
  "include_details": true
}
```

# Actor output Schema

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

One row per unique event.

## `output` (type: `string`):

Counts, status, warnings and continuation metadata.

## `errors` (type: `string`):

Redacted source errors when present.

# 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 = {
    "start_urls": [
        "https://www.facebook.com/mojoconcerts"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/facebook-events").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 = { "start_urls": ["https://www.facebook.com/mojoconcerts"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/facebook-events").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 '{
  "start_urls": [
    "https://www.facebook.com/mojoconcerts"
  ]
}' |
apify call s-r/facebook-events --silent --output-dataset

```

## MCP server setup

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

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/pT1jijJnvsbCrH43Z/builds/3ZKh7AdbPgb47w5KH/openapi.json