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

Find public Facebook events by keyword, city, organizer Page or event URL. Get dates with time zones, venues with coordinates, organizers, ticket links, cover images and attendance counts. No Facebook login or cookies needed.

- **URL**: https://apify.com/coregent/facebook-events-scraper.md
- **Developed by:** [Delowar Munna](https://apify.com/coregent) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 event results

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 — Events, Venues, Organizers, Tickets & Attendance

![Facebook Events Scraper — find public Facebook events by keyword, city, Page or event URL](https://raw.githubusercontent.com/coregentdevspace/facebook-events-scraper-assets/main/thumbnail-facebook-events-scraper.png)

**Find public Facebook events by keyword, city, organizer Page or event URL** — and get one clean row per event with its dates and time zone, venue and coordinates, organizer, ticket link, cover image and attendance count. Export to JSON, CSV or Excel, or feed it straight into your own tools.

- 🔎 **Search, Pages and direct URLs in one run** — mix keywords, organizer Pages and event links; every event comes back **once**, listing every route that found it
- 📅 **Day-by-day search** — each keyword is searched across your date range one day at a time, which finds several times more events than a single Facebook search
- 🕐 **Real local times** — `startTime` in the event's own time zone with its UTC offset, plus exact UTC instants
- 📍 **Venues with coordinates**, city, address and the venue's Facebook page where the organizer set one
- 🎟️ **Organizers, co-hosts, ticket links, cover images and attendance counts**
- ✅ **Strict filters** — date range, upcoming/past, in-person/online and location are checked against each event's own page, not just trusted from search
- 🔓 **No Facebook login, cookies, account or token**
- 💸 **Pay only for events delivered** — searches, page reads, retries, duplicates and filtered-out events are never charged

***

### What can I give it?

| Input                   | Use it for                                    | Example                                                                                  |
| ----------------------- | --------------------------------------------- | ---------------------------------------------------------------------------------------- |
| **Search terms**        | Discovering events by topic                   | `live music`, `food festival`, `startup networking`                                      |
| **Facebook Page URLs**  | Every event of a venue, promoter or organizer | `https://www.facebook.com/CMEventsLive`                                                  |
| **Facebook event URLs** | Reading specific events                       | `https://www.facebook.com/events/1869688844197879/`, a numeric ID, or a `fb.me/e/…` link |
| **Location** (optional) | Keeping only events in a city                 | `Canberra, ACT, Australia`                                                               |

Give any one of the first three, or any mix. The mode is worked out from what you supply.

### Quick start

#### Keyword search in a city

```json
{
    "searchTerms": ["live music"],
    "location": "Canberra, ACT, Australia",
    "maxEvents": 100
}
```

#### Several keywords, the next 30 days, in person only

```json
{
    "searchTerms": ["live music", "food festival", "startup networking"],
    "location": "Sydney, NSW, Australia",
    "startDateFrom": "+0 days",
    "startDateTo": "+30 days",
    "eventFormat": "IN_PERSON",
    "maxEvents": 500
}
```

#### All upcoming events of some organizer Pages

```json
{
    "pageUrls": ["https://www.facebook.com/CMEventsLive"],
    "eventTiming": "UPCOMING",
    "maxEventsPerPage": 100,
    "maxEvents": 500
}
```

#### Specific events

```json
{
    "eventUrls": ["https://www.facebook.com/events/1869688844197879/"]
}
```

#### Mixed — search, Pages and URLs together

```json
{
    "searchTerms": ["tech meetup"],
    "location": "Melbourne, VIC, Australia",
    "pageUrls": ["https://www.facebook.com/exampletechcommunity"],
    "eventUrls": ["https://www.facebook.com/events/1869688844197879/"],
    "maxEvents": 500
}
```

### Input

| Field                           | Default    | What it does                                                                                                                                |
| ------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `searchTerms`                   | `[]`       | Keywords. Up to 100.                                                                                                                        |
| `pageUrls`                      | `[]`       | Page URLs, handles or `profile.php?id=` links. Up to 200.                                                                                   |
| `eventUrls`                     | `[]`       | Event URLs, IDs or `fb.me/e/` short links.                                                                                                  |
| `maxEvents`                     | `100`      | Most unique events delivered in the run, across all inputs.                                                                                 |
| `maxEventsPerPage`              | `100`      | Most events taken from each Page.                                                                                                           |
| `eventTiming`                   | `UPCOMING` | `UPCOMING`, `PAST` or `ALL`.                                                                                                                |
| `startDateFrom` / `startDateTo` | —          | `2026-10-24`, or relative: `today`, `+7 days`, `-1 month`. Compared with the event's **local** date.                                        |
| `eventFormat`                   | `ALL`      | `ALL`, `IN_PERSON` or `ONLINE`.                                                                                                             |
| `location`                      | —          | A city, ideally with region and country. See [location](#can-i-filter-by-city).                                                             |
| `locationUrl`                   | —          | Advanced: a Facebook city URL or numeric city ID, for an exact city match.                                                                  |
| `listOnly`                      | `false`    | On = a fast list of IDs and names (plus dates and cities for Page events) without reading event pages. Off = every row carries all details. |
| `maxConcurrency`                | `10`       | Event pages read in parallel.                                                                                                               |

Malformed URLs, negative limits and a start date after the end date are rejected before anything runs, with a message saying what to fix.

### Output

One row per unique event. A real row from the default input (`"searchTerms": ["live music"]`, upcoming), run on Apify — description, image URLs and ticket link shortened, and 2 of its 9 co-hosts shown:

```json
{
    "rowType": "event",
    "eventId": "1103030832675964",
    "eventUrl": "https://www.facebook.com/events/1103030832675964/",
    "name": "Salsa, Bachata Dancing + Dance Lessons | San Francisco's #1 Dance Club",
    "description": "San Francisco's #1 Salsa & Bachata nightclub. 2 rooms of dancing, live DJs, and beginning + intermediate dance…",
    "startTime": "2026-10-23T19:45:00-07:00",
    "endTime": "2026-10-24T01:30:00-07:00",
    "startTimeUtc": "2026-10-24T02:45:00.000Z",
    "endTimeUtc": "2026-10-24T08:30:00.000Z",
    "timezone": "PDT",
    "utcOffset": "-07:00",
    "dateText": "Friday, October 23, 2026 at 7:45 PM – 1:30 AM PDT",
    "durationText": "5 hr 45 min",
    "eventFormat": "IN_PERSON",
    "onlineEventUrl": null,
    "venue": {
        "name": "550 Barneveld,San Francisco,94124,US",
        "address": "550 Barneveld Ave, San Francisco, CA 94124-1804, United States",
        "city": "San Francisco",
        "cityFullName": "San Francisco, California",
        "cityId": "114952118516947",
        "latitude": 37.73995,
        "longitude": -122.40471,
        "facebookPlaceId": null,
        "facebookPlaceUrl": null
    },
    "organizer": {
        "name": "Dance San Francisco",
        "url": "https://www.facebook.com/dancesanfrancisco",
        "id": "100080088835447",
        "isVerified": false,
        "imageUrl": "https://scontent…"
    },
    "coHosts": [
        {
            "name": "DanceSF Salsa Dance Academy",
            "url": "https://www.facebook.com/dancesf",
            "id": "100068679109648",
            "isVerified": false
        },
        {
            "name": "Dance Saturdays",
            "url": "https://www.facebook.com/dancesaturdays",
            "id": "100067008592618",
            "isVerified": false
        }
    ],
    "ticket": {
        "url": "https://www.eventbrite.com/e/salsa-bachata-dancing-dance-lessons-san-franciscos-1-dance-club-tickets-…",
        "provider": "Eventbrite",
        "priceText": null
    },
    "attendance": {
        "goingCount": null,
        "interestedCount": null,
        "respondedCount": 0
    },
    "category": null,
    "categories": [],
    "coverImageUrl": "https://scontent…",
    "status": "SCHEDULED",
    "isRecurring": false,
    "seriesId": null,
    "occurrenceId": null,
    "locationMatchStatus": null,
    "inputSources": ["SEARCH"],
    "matchedSearches": ["live music"],
    "matchedPages": [],
    "matchedEventUrls": [],
    "detailLevel": "FULL",
    "scrapedAt": "2026-10-21T01:55:55.126Z"
}
```

#### Field notes

- **Times.** `startTime` / `endTime` are the event's local wall-clock time with its UTC offset. `timezone` is Facebook's own label (`AEDT`, `EDT`, `UTC+11`) — Facebook shows no IANA zone name to logged-out visitors, so `utcOffset` is the machine-readable part. `startTimeUtc` / `endTimeUtc` are exact. Events with no end time have `endTime: null`.
- **`eventFormat`** — `IN_PERSON`, `ONLINE`, or `UNKNOWN` (list-only rows).
- **`status`** — `SCHEDULED`, `CANCELED`, `PAST` or `UNKNOWN`, only as Facebook states it. Facebook shows no "postponed" flag to logged-out visitors, so `POSTPONED` is never guessed.
- **`venue`** — `null` when the organizer set no place (common for online events). Coordinates appear when the venue is a Facebook place; they are never geocoded.
- **`attendance.respondedCount`** — Facebook's public "people responded" number, which is going + interested together. Logged-out pages do not split it, so `goingCount` and `interestedCount` are `null` rather than estimated. **No attendee names or profiles are ever collected.**
- **Recurring events** — each occurrence is its own row with its own `eventId`; `seriesId` links it to its series. A series link (from search or a URL) is delivered as the occurrence its page shows, with that occurrence's date, venue and organizer.
- **Attribution** — `inputSources` (`SEARCH`, `PAGE`, `DIRECT_EVENT`) and `matchedSearches` / `matchedPages` / `matchedEventUrls` list every route that found the event.
- **`detailLevel`** — `FULL` when the event's page was read, `DISCOVERY_ONLY` when `listOnly` was on.

#### Output views and sample records

The dataset has three table views. One real record per view, from the same default-input run:

![Facebook Events Scraper output — Events table view](https://raw.githubusercontent.com/coregentdevspace/facebook-events-scraper-assets/main/facebook-events-scraper-output-events-table-view.png)

**Events** — name, local start/end, time zone, format, venue, city, organizer, responded count, status, URL, how it was found:

```json
{
    "name": "Everyone Orchestra ft. Natalie Cressman & Lebo (ALO) @ the Mission Theater",
    "startTime": "2026-10-23T20:00:00-07:00",
    "endTime": null,
    "timezone": "PDT",
    "eventFormat": "IN_PERSON",
    "venue.name": "McMenamins Mission Theater",
    "venue.city": "Portland",
    "organizer.name": "McMenamins Mission Theater",
    "attendance.respondedCount": 29,
    "status": "SCHEDULED",
    "eventUrl": "https://www.facebook.com/events/1715514443043269/",
    "inputSources": ["SEARCH"]
}
```

**Venues & location** — venue, address, city, coordinates, the venue's Facebook page, location match:

```json
{
    "name": "Skillet Tickets",
    "startTime": "2026-10-22T18:00:00-06:00",
    "venue.name": "Fillmore Auditorium",
    "venue.address": "1510 Clarkson St, Denver, CO 80218",
    "venue.city": "Denver",
    "venue.cityFullName": "Denver, Colorado",
    "venue.latitude": 39.740460064575,
    "venue.longitude": -104.9771386385,
    "venue.facebookPlaceUrl": "https://facebook.com/FillmoreDEN",
    "locationMatchStatus": null,
    "onlineEventUrl": null,
    "eventUrl": "https://www.facebook.com/events/2192375444877615/"
}
```

**Organizers & tickets** — organizer, verification, ticket link and provider, price text, responded count, category:

```json
{
    "name": "Best of the Boat winners celebration",
    "startTime": "2026-10-22T17:00:00-06:00",
    "organizer.name": "Steamboat Pilot & Today",
    "organizer.url": "https://www.facebook.com/steamboatpilot",
    "organizer.isVerified": true,
    "ticket.url": "https://strings.my.salesforce-sites.com/ticket/#/events/a0SUk0000012Zh3MAE",
    "ticket.provider": "strings.my.salesforce-sites.com",
    "ticket.priceText": null,
    "attendance.respondedCount": 24,
    "category": null,
    "eventUrl": "https://www.facebook.com/events/1471353648195282/"
}
```

`locationMatchStatus` is `null` here because the run had no `location`; with one it is `EXACT`, `CITY_MATCH` or `REGION_MATCH` (see [location](#can-i-filter-by-city)).

#### Run summary and retries

Every run writes `RUN_SUMMARY` to the key-value store: events discovered, unique, delivered, duplicates merged, how many each filter removed, Pages with no events, failed inputs, the status of every input (`SUCCESS`, `NO_EVENTS`, `PAGE_NOT_FOUND`, `EVENT_NOT_FOUND`, `INVALID_URL`, `RATE_LIMITED`, `BLOCKED`, `PARTIAL_RESULT`, `TEMPORARY_FACEBOOK_ERROR`, `PROVIDER_ERROR`) and field availability. One failed input never fails the run. If anything did not finish, `RETRY_INPUT` holds a ready-to-run input with just those search terms, Pages and events.

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

No. The Actor reads only what Facebook shows a logged-out visitor: its own Events search, a Page's events tab and the event's public page. It never asks for a login, cookies, a session or a Meta API token.

### Can I search by keyword?

Yes. Each search term is searched without a date filter, then across your whole date range, then **one day at a time** across that range (the next 30 days when you give no dates). Facebook answers each of those searches with a different short list, so together they find far more: in our tests one keyword returned 6 events from a single search and 44 distinct events from four date-filtered ones.

### Why can keyword search return a limited number of events?

Facebook's logged-out event search returns a short list per search — often 5–25 events — and offers no way to page further. Day-by-day searching widens it a lot, but **keyword search is not exhaustive** and we do not market it as such. For broad coverage use:

> **several related keywords + the organizer Pages you care about + direct event URLs**

Pages are the deep route: a Page's events tab lists every public event it hosts (we measured 709 upcoming and 9,295 past events on one Page).

### Can I filter by city?

Yes, with two honest caveats.

With `location` set, each search term is searched together with the city (`live music Canberra`), and **every event is checked against its own venue**:

| `locationMatchStatus`        | Meaning                                                                                 | Kept?                     |
| ---------------------------- | --------------------------------------------------------------------------------------- | ------------------------- |
| `EXACT`                      | the venue's Facebook city ID is the one in `locationUrl`                                | ✅                        |
| `CITY_MATCH`                 | the venue is in the named city (and its region/country agrees)                          | ✅                        |
| `REGION_MATCH`               | a different town in the region you named (e.g. Wollongong for `Sydney, NSW, Australia`) | ✅                        |
| `OUTSIDE_REQUESTED_LOCATION` | somewhere else — including a same-named city elsewhere (Sydney, Nova Scotia)            | ❌                        |
| `UNKNOWN`                    | the event's page shows no venue at all                                                  | ❌ when the page was read |

1. **Facebook cannot look up a city name for a logged-out visitor**, so the city is matched against each venue rather than passed to Facebook's own city filter. If you know the city's Facebook ID, `locationUrl` passes it to Facebook's filter too and matches it exactly.
2. **City search is shallow.** Facebook's logged-out search returns few events for a keyword in one city. For a city, add the Pages of its main venues and promoters — that is where the depth is.

### Can I scrape Page events?

Yes. Give Page URLs or handles. Upcoming events come soonest-first and past events most-recent-first, and reading stops as soon as the list passes your date range. A Page with no events is reported as `NO_EVENTS`, not as an error; a Page that does not exist is `PAGE_NOT_FOUND`.

### Can I use direct event URLs?

Yes — full URLs, numeric IDs, `fb.me/e/…` short links, and a recurring event's occurrence link (`…?event_time_id=…`, read as that occurrence). A private, deleted or non-existent event is reported as `EVENT_NOT_FOUND` (logged out, Facebook does not say which of the three it is).

### Are past events supported?

Yes — `eventTiming: "PAST"` or `"ALL"`. Page past-event lists are the richest source.

### Are online events supported?

Yes. `eventFormat: "ONLINE"` keeps only online events; `onlineEventUrl` carries the joining link when Facebook shows it publicly.

### Are venue coordinates, ticket links and going/interested counts included?

- **Coordinates** — yes, when the venue is a Facebook place (most venue-based events). Free-text venues have none, and nothing is geocoded.
- **Ticket links** — yes, with the ticket provider's domain and Facebook's price text when the organizer set them.
- **Attendance** — the public **responded** count (going + interested combined). The separate going and interested numbers are not shown to logged-out visitors, so those fields stay `null`.
- **Attendee identities** — never. This Actor returns counts, not people.

### Are Group events supported?

No. Events hosted inside Facebook Groups need a login to see, and this Actor never logs in.

### 💸 How is pricing calculated?

Pay per event: you are charged **once per unique event delivered** to your dataset. An event found by several keywords, Pages and URLs is delivered and charged once.

Never charged: searches, Page list requests, event-page reads, retries, duplicates, events removed by your filters, failed inputs, and runs that find nothing. There is no start fee.

The current price per event is on the Actor's **Pricing** tab. This README deliberately doesn't quote figures, so it can never disagree with the live price.

Your Apify spending limit is respected: the run stops cleanly at the limit with everything paid for so far.

### Can I schedule runs?

Yes — save an input as a Task and schedule it in Apify (daily, weekly…). A weekly run over your city's venue Pages is a simple event calendar.

### Can I call it through the API or MCP?

Yes. Run it with the Apify API or client libraries and read the dataset, or connect it to an AI agent through the Apify MCP server.

```bash
curl -X POST "https://api.apify.com/v2/acts/coregent~facebook-events-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"pageUrls":["https://www.facebook.com/CMEventsLive"],"maxEvents":50}'
```

### 🔗 More Coregent Facebook Actors

Event organizers and venues are Facebook Pages — pass their URLs to our other Facebook Actors for posts, comments and search across the rest of public Facebook.

### 🚦 Proxy policy

Use **Apify Datacenter** proxy (the default) or **no proxy** for normal runs.

**Apify Residential proxy is not supported.** The Actor fails at startup if `apifyProxyGroups` includes `RESIDENTIAL`. Reason: in pay-per-event Actors, residential bandwidth is billed to the developer, not the run user, and event pages are large, so a single run could cost more than the events it delivers.

If you genuinely need residential routing, supply your own provider via the proxy editor's **Custom proxy URLs** field — that traffic goes through your provider, not Apify:

```
http://user:pass@proxy.iproyal.com:12321
http://user:pass@proxy.brightdata.com:22225
http://user:pass@proxy.oxylabs.io:7777
```

### Limitations

- Keyword and city search are limited per search by Facebook (see above) — combine keywords, Pages and URLs for coverage.
- Going / interested are not split for logged-out visitors; only the responded total is.
- No IANA time zone name — Facebook's label plus the exact UTC offset.
- No "postponed" status, Group events, private events, attendee lists or ticket inventory.
- Event details and counts change over time; a row is a snapshot at `scrapedAt`.

### Privacy and responsible use

This is an unofficial product, not affiliated with or endorsed by Meta or Facebook. It processes **public** events only and never logs in, collects credentials, sends invitations or messages, or collects attendee identities. Public attendance counts do not imply anyone's consent to be contacted. You are responsible for using the data lawfully, including privacy and anti-spam rules where you operate.

### Need something else?

Open an issue on the Actor's **Issues** tab — tell us the event, Page or search that did not work and what you expected.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to find public Facebook events with, e.g. "live music", "food festival", "tech meetup". Each term is searched day by day across your date range, which finds far more events than a single search. Facebook's logged-out event search is limited per keyword, so several related terms (plus organizer Pages) give the broadest coverage. Up to 100 terms. Leave empty to use only Pages or event URLs.

## `pageUrls` (type: `array`):

Public Facebook Pages whose events you want — venues, promoters, organizers. A Page URL (https://www.facebook.com/<page>), its handle, or a profile.php?id= link. The best way to get every event of a known organizer.

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

Specific public events to read: https://www.facebook.com/events/<id>/, a numeric event ID, or a fb.me/e/ short link. A recurring event's occurrence link (…?event_time_id=…) is read as that occurrence.

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

The most unique events to deliver in this run, across all inputs. You are charged only for events actually delivered.

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

The most events to take from EACH Page in "Facebook Page URLs".

## `eventTiming` (type: `string`):

Upcoming events (the default), past events, or both. Checked against each event's own page.

## `startDateFrom` (type: `string`):

Only events starting on or after this date, in the event's own local time. A date (2026-10-24) or a relative date such as "today", "+7 days" or "-1 month".

## `startDateTo` (type: `string`):

Only events starting on or before this date, in the event's own local time. A date (2026-11-30) or a relative date such as "+30 days". With search terms and no dates, the next 30 days are searched.

## `eventFormat` (type: `string`):

In-person events, online events, or both.

## `location` (type: `string`):

Optional city, e.g. "Canberra, ACT, Australia". Search terms are searched together with the city, and every event is checked against its venue: same city kept, nearby places in the same region kept and marked REGION_MATCH, everything else (including events with no venue) dropped. Include the region or country to tell same-named cities apart. Facebook's logged-out search is shallow for a single city — add organizer Pages for depth.

## `locationUrl` (type: `string`):

Optional and advanced. A Facebook city page or events-explore URL ending in the city's numeric ID (e.g. https://www.facebook.com/events/explore/canberra-australian-capital-territory/106270089409734/), or just the ID. Passed to Facebook's own search filter and matched EXACTLY against each venue's city.

## `listOnly` (type: `boolean`):

Off (recommended): every event's own page is read, so each row carries its description, end time, venue address and coordinates, organizer and co-hosts, ticket link, cover image and attendance count, and the location filter can check the venue. On: a fast list of event IDs and names (plus dates and cities for Page events) without reading event pages; a location filter then cannot check venues. Direct event URLs are always read.

## `maxConcurrency` (type: `integer`):

How many event pages are read at the same time. Lower it if you see rate-limit warnings.

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

Apify Datacenter proxy is used by default. Apify Residential proxy is not supported and fails the run — use your own residential provider under "Custom proxy URLs" if you need one.

## `debug` (type: `boolean`):

Log every request outcome. For troubleshooting.

## Actor input object example

```json
{
  "searchTerms": [
    "live music"
  ],
  "pageUrls": [],
  "eventUrls": [],
  "maxEvents": 100,
  "maxEventsPerPage": 100,
  "eventTiming": "UPCOMING",
  "startDateFrom": "",
  "startDateTo": "",
  "eventFormat": "ALL",
  "location": "",
  "locationUrl": "",
  "listOnly": false,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `venues` (type: `string`):

No description

## `organizers` (type: `string`):

No description

## `runSummary` (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 = {
    "searchTerms": [
        "live music"
    ],
    "pageUrls": [],
    "eventUrls": [],
    "maxEvents": 100,
    "maxEventsPerPage": 100,
    "eventTiming": "UPCOMING",
    "eventFormat": "ALL",
    "maxConcurrency": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("coregent/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 = {
    "searchTerms": ["live music"],
    "pageUrls": [],
    "eventUrls": [],
    "maxEvents": 100,
    "maxEventsPerPage": 100,
    "eventTiming": "UPCOMING",
    "eventFormat": "ALL",
    "maxConcurrency": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("coregent/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 '{
  "searchTerms": [
    "live music"
  ],
  "pageUrls": [],
  "eventUrls": [],
  "maxEvents": 100,
  "maxEventsPerPage": 100,
  "eventTiming": "UPCOMING",
  "eventFormat": "ALL",
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call coregent/facebook-events-scraper --silent --output-dataset

```

## MCP server setup

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