Facebook Events Scraper — Past the 8-Event Limit

The only Facebook scraper that returns an organizer's full event calendar, past and upcoming, not just the 8 events Facebook shows logged-out visitors. Paste an event, page, group, or city URL, or just search by keyword → get clean, structured data. No login, no headless browser. $4 per 1,000 events, all inclusive. The official scraper charges $13, and stops at the 8-event cap.

---

Why Facebook only shows 8 events when you are logged out

Open any active Facebook page's events tab in an incognito window. You'll see 8 upcoming events, then a "Log in to see more" wall. That cap is not an API limit — the data is public, Facebook just hides it from logged-out visitors. Even the official apify/facebook-events-scraper actor admits in its docs that for pages and groups it "will return only recent events that regular Facebook users can see without scrolling."

This actor reaches the rest by paginating the public surface directly. On a typical festival promoter or major venue we return 50–200+ events where every other Apify FB scraper stops at 8.

What does it cost to scrape Facebook events?

	Price
Per Facebook event scraped	$4.00 / 1,000
Per Facebook organizer scraped	$5.00 / 1,000
Per actor start (waives first 5s compute)	$0.00005

Worked example: A typical run that scrapes one venue page and pulls its 50 upcoming events:

1 organizer profile  × $5 / 1,000  = $0.005
50 events scraped    × $4 / 1,000  = $0.200
─────────────────────────────────────────────
                              total = $0.205

No subscription, no minimum spend.

What the caps actually do. maxTotalEvents, maxEventsPerOrganizer and maxTotalOrganizers are checked before each event is fetched, not after it lands. A run cannot overshoot the number you set, so the figure you type is the most you can be charged for.

What you are not charged for:

• Events that never reach your dataset. Failed retries, skipped duplicates and anything cut off by a cap are free.
• An input that returns nothing. A dead page or a city with no upcoming events costs you the $0.00005 start charge and nothing else.
• Compute and residential proxy. Both are covered by the per-event price and are never billed on top.

If the full record is more than you need, eventDetail: "list" returns just name, date, venue, city, cover photo and host, roughly 4x faster, at the same per-event price. See Full vs. list detail.

For comparison, the official apify/facebook-events-scraper charges $13 per 1,000 events on its Free plan and $7 on Business. At $4 this actor is 69% cheaper than their Free price and 43% cheaper than their Business price, and it goes deeper (past the 8-event cap).

How to scrape Facebook events: quickstart

Paste any of these into Paste Facebook URLs:

https://www.facebook.com/TEDxAmsterdam
https://www.facebook.com/events/666594420519340/
666594420519340
TEDxAmsterdam
https://www.facebook.com/groups/123456789012345/
https://www.facebook.com/places/Things-to-do-in-Detroit-Michigan/114586701886732/

Each line is auto-detected as an event, an organizer page, a group, or a city/place. Mix freely.

No URL? Use Search Facebook events by keyword instead, one query per line:

techno berlin
comedy

Keyword searches run alongside whatever you paste above, in the same run.

Pasting is forgiving. A missing or mangled https://, a bare www.facebook.com/..., or a URL your mail client wrapped in quotes all work.

The Cascade depth dial controls how deep the actor follows the social graph from each input:

• 0 — scrape just what you paste. Cheapest, fastest. Event → 1 event row. Organizer → 1 profile row. Group → its events. City → its events.
• 1 (default) — also pull each organizer's full event calendar AND each event's host profiles. The sweet spot for most users.
• 2 — follow co-host relationships one more hop (organizer → events → those events' hosts). Also the depth at which a city's events yield their host profiles, since those events are already one hop from the input.
• 3–5 — recursive deep cascade. From a city input this is where the volume is: depth 3 scrapes the full calendar of every organizer found in the city feed. Use with maxTotalEvents to cap spend.

Pick an events time range — upcoming (default), past, or both. The two total caps (maxTotalEvents and maxTotalOrganizers) give you a hard ceiling on spend per run regardless of cascade depth.

Full detail or list only: which should I pick?

The Event detail level setting decides how much we fetch per event (the per-event price is the same either way):

• full (default) — scrape every event's complete detail: description, exact coordinates, ticket link, attendee count, end time, categories. Richest data.
• list — emit events straight from the organizer's listing: name, date, venue, city, cover photo, and host — but skip the detail-only fields. Runs roughly 4× faster because it skips the per-event detail fetch. The cascade still expands hosts in this mode — except for city/place inputs, where Facebook's discovery feed doesn't name the host, so full is required to follow it.

If you're an aggregator that just needs "what's on, where, and when" with a cover image, list mode is faster. Switch to full only when you need descriptions, tickets, or precise coordinates.

How to search Facebook events by keyword

When you have an idea rather than a URL, put it in searchQueries. The actor runs Facebook's own event search and paginates it, so you get well past the handful of results the search page shows.

It is the only input that reaches past events properly. Facebook's search returns past and upcoming results mixed together, which means the events time range setting is a real filter here, not a formality:

• upcoming (default) keeps only events that have not happened yet. Measured on "techno berlin": 13 of the results.
• past keeps only events that already happened. Organizers, groups and keyword search all reach them. The past tab paginates exactly like upcoming (measured: 60 past events off one page and 39 off one group, versus the 8 a logged-out visitor sees).
• both returns everything.

Search results carry no organizer, exactly like city discovery, so eventDetail: "full" and cascadeDepth: 2 are needed to resolve hosts from them.

How deep a query goes is Facebook's decision. A broad term keeps paginating; a narrow one runs out after a page or two, and the actor stops as soon as Facebook stops returning anything new.

How to find all Facebook events in a city

Paste a Facebook city page — https://www.facebook.com/places/Things-to-do-in-Detroit-Michigan/114586701886732/ — and the actor returns the events Facebook surfaces for that city. The /events/explore/… form of the same URL works too.

How it works. A city page has no events tab of its own, so the actor reads Facebook's public event-discovery feed for that place id and paginates it. A browser shows you about 11 events there before the feed stops loading; the actor keeps going. Detroit returns 150 to 200 events in well under a minute, spanning roughly three months ahead. How deep the feed goes varies by city and by day, so treat those numbers as the shape of it rather than a guarantee.

How many you get is up to you. maxEventsPerOrganizer is the per-city cap and it goes up to 1,000 (default 50, so raise it for cities). maxTotalEvents still bounds the whole run on top. The actor stops fetching the moment a cap is reached, so a lower number genuinely costs less.

What this is not. This is Facebook's own curated suggested events ranking for a city, not an exhaustive index of everything happening there. Facebook decides what to surface, and it mixes big-venue concerts with genuine long-tail community events (farmers' markets, yoga meetups, bike tours). Treat it as high-quality discovery, not as a complete city calendar. If you need completeness for specific venues, feed their page URLs in as organizers.

Turning a city into organizers. This is the highest-value way to use it. At cascadeDepth: 2 the actor resolves the organizer behind every city event and emits their profiles, which gives you a ready-made list of the active event hosts in a region. At cascadeDepth: 3 it then scrapes each of those organizers' full calendars, which is where the numbers really scale. Both need eventDetail: "full", because the discovery feed itself does not name the host.

Limitations. Upcoming events only (the discovery feed has no past events, so eventsTimeRange: "past" returns nothing for a city). Events arrive without a host, so cascading from a city needs eventDetail: "full" and cascadeDepth: 2.

What data do you get for each event?

The dataset writes one row per scraped entity, tagged with type. Every row also carries discoveredVia, which tells you whether it came from something you pasted (input) or was found by expansion (organizer-expansion, group-expansion, place-expansion). Switch between the Events and Organizers tabs to see rich previews — cover photos render inline, dates are parsed, links are clickable. Export as JSON, CSV, Excel, or via the Apify API.

Event row

{
  "type": "event",
  "discoveredVia": "organizer-expansion",
  "id": "1234567890123456",
  "name": "TEDxAmsterdam 2026: Ideas Worth Spreading",
  "description": "...",
  "startTimestamp": 1763110800,
  "endTimestamp": 1763136000,
  "formattedDate": "Sat, Nov 14, 2026 at 9:00 AM",
  "timezone": "Europe/Amsterdam",
  "location": {
    "name": "Royal Theater Carré",
    "city": { "name": "Amsterdam" },
    "coordinates": { "latitude": 52.362, "longitude": 4.901 }
  },
  "hosts": [
    { "id": "100064...", "name": "TEDxAmsterdam", "type": "Page" }
  ],
  "photo": { "imageUri": "https://..." },
  "ticketUrl": null,
  "isCanceled": false,
  "isOnline": false,
  "usersResponded": 412,
  "url": "https://www.facebook.com/events/1234567890123456/"
}

Organizer row

{
  "type": "organizer",
  "discoveredVia": "input",
  "id": "100064xxxxxxxxx",
  "name": "TEDxAmsterdam",
  "vanity": "TEDxAmsterdam",
  "url": "https://www.facebook.com/TEDxAmsterdam",
  "category": "Nonprofit Organization",
  "isVerified": false,
  "description": "...",
  "contextualName": "Amsterdam, Netherlands",
  "profilePicture": { "small": "https://...", "medium": "https://...", "large": "https://..." },
  "coverPhoto": { "imageUri": "https://..." }
}

Error row

A bad input never aborts the run — it becomes a row you can filter on:

{
  "type": "error",
  "input": "not-a-real-thing",
  "reason": "Unrecognised input: not-a-real-thing. Accepted: an event URL or numeric event id; an organizer page URL or vanity name; a group URL; or a city/place URL (facebook.com/places/<name>/<id>/ or facebook.com/events/explore/<name>/<id>/)."
}

How does this compare to other Facebook event scrapers?

	This actor	apify/facebook-events-scraper (official)	Keyword-search actors
Past Facebook's 8-event cap	✅	❌ (only what logged-out visitors see)	❌
Auto-detects event / page / group / city input	✅	partial	❌
Keyword search	✅	✅	✅
Cascade expansion (event → host → host's events)	✅	❌	❌
City event discovery (FB's curated feed for a place, all date windows)	✅	❌	partial
Past events beyond Facebook's 8-item logged-out cap	✅ (organizers and groups paginate; also via keyword search)	❌	❌
Pricing	$4 / 1,000 events	$13 / 1,000 events (Free), $7 (Business)	$1 to $5 / 1,000
Speed (typical 50-event organizer)	~30 seconds	~minutes	~minutes

This actor is built for deep extraction, with city discovery as an entry point into it. If you need keyword search, use one of the search-based actors and pipe their resulting organizer URLs back into this one — they're complementary, not competitors.

What can you use Facebook event data for?

• Event aggregators and discovery platforms — bulk-import an entire region's events from a list of venues, brands, or groups.
• Lead generation — find organizers active in your niche and their upcoming events for outreach campaigns.
• Mapping who runs events in a region — paste a city page at cascade depth 2 and you get the organizer profile behind every event Facebook surfaces there, which is a ready-made prospect list. Depth 3 then pulls each of those organizers' full calendars.
• Market and competitor research — track who's running events where, at what cadence, in which categories.
• Local guides and weekend-calendar feeds — auto-populate "what's on this week" listings without writing your own crawler.

Input reference: every setting explained

Field	Type	Default	Notes
inputs	string[]	(optional)	Event URLs, event IDs, organizer/page URLs, organizer vanity names, group URLs, city/place URLs (/places/…/<id>/ or /events/explore/…/<id>/). Auto-classified per item.
searchQueries	string[]	[]	Free-text Facebook event searches, one per line. Runs alongside inputs. Reaches past events as well as upcoming.
cascadeDepth	integer (0–5)	1	Number of expansion hops from each input. See the cascade ladder above.
eventsTimeRange	enum	"upcoming"	"upcoming", "past", or "both". Applies to organizer/group expansion and is a real filter for keyword search, which mixes past and upcoming. Cities are upcoming-only.
eventDetail	enum	"full"	"full" = complete per-event detail. "list" = name/date/venue/city/cover/host only, ~4× faster (same per-event price). City events carry no host in "list" mode.
maxEventsPerOrganizer	integer (1–1,000)	50	Caps how many events are pulled per expanded organizer, group, or city. Raise it for cities: the discovery feed keeps paginating well past 200 events, and this cap is what stops it.
maxTotalEvents	integer (1–5,000)	500	Hard global cap on events scraped per run. Checked before each full event scrape — you never pay for events that don't appear in the dataset.
maxTotalOrganizers	integer (1–1,000)	100	Hard global cap on organizer profiles scraped per run.
proxyConfiguration	object	Apify Proxy RESIDENTIAL	Residential proxy is required — Facebook blocks datacenter IPs. Country dropdown in the UI lets you pin to a region (e.g. GB for UK events).

FAQ

Do I need cookies or a Facebook account? No. The actor reads only public data, as a logged-out visitor would.

Why a residential proxy? Facebook blocks datacenter IPs. The default RESIDENTIAL group of Apify Proxy is enough — no extra setup. You can optionally pin to a country in the proxy editor.

What about past events? Set eventsTimeRange to "past" or "both". Organizer and group inputs both paginate the past tab in full. Organizer rows carry the same fields either way (cover photo, host, venue, timestamp); group rows carry fewer on both tabs, because Facebook's group listing omits cover photo and host. City/place inputs are upcoming-only: Facebook's discovery feed exposes no past events.

Can I scrape all events in a city? Paste a Facebook city page and the actor paginates Facebook's discovery feed for it, returning hundreds of events rather than the ~11 a browser shows. See City / place event discovery. Be aware it's Facebook's curated ranking for that city, not a guaranteed-complete calendar. For completeness on specific venues, paste their page URLs as organizers.

How do I find event organizers in a region? Paste the city page with cascadeDepth: 2 and eventDetail: "full". You get the organizer profile behind every event the city feed surfaces, which is a ready-made list of who is actually running events there. cascadeDepth: 3 goes one further and scrapes each of those organizers' full calendars.

Can I search by keyword? Yes. Put your terms in searchQueries, one per line. See Keyword search. Note that Facebook mixes past and upcoming results there, so the events time range setting matters more than usual.

How do I get past events? For an organizer or group, set eventsTimeRange, but Facebook caps those at 8. Keyword search is the exception: it reaches much further back, so a keyword query with eventsTimeRange: "past" is the practical way to get event history.

How long does a typical run take? A 50-event organizer scrape finishes in under 30 seconds. A cascade-depth-3 run with 500 events typically takes 2–4 minutes. HTTP-only architecture — no Chromium overhead.

What about Apify platform costs (compute, proxy bandwidth)? The price is all-inclusive. You pay only the per-event and per-organizer charges above — compute and residential proxy are covered, not billed on top. There's no surprise platform bill.

What's the difference between full and list detail then? Purely data richness and speed — the per-event price is the same either way. full returns every field (description, coordinates, tickets, attendee count). list returns name, date, venue, city, cover photo, and host, and runs roughly 4× faster because it skips the per-event detail fetch. Choose list if you only need "what's on, where, when" with a cover image; choose full when you need the rest.

A run failed — what now? Re-run it. Runs are billed only on successful scrapes — failed events don't appear in your dataset and aren't charged. See RUNBOOK.md in the actor's GitHub for troubleshooting. If Facebook changes its public surface, watch the version log: typical hotfix turnaround is within hours.

Can I run this on millions of events? Yes — use the maxTotalEvents cap to bound spend. The actor streams to the dataset as it scrapes, so you can pause/resume large jobs via Apify's scheduler.

Support

For bugs or feature requests, use the Issues tab on this actor's Apify Store page. Runs are billed only on successful scrapes, so a failed run costs you nothing while we investigate.