Facebook Group Posts & Detail Scraper: Keyword & Content Filter

Facebook Group Scraper — Extract Posts, Authors & Groups as JSON

This Facebook group scraper extracts feed posts, post-author details, and group profile data from any public Facebook group — starting from a direct group URL or from a list of discovery keywords instead. Every result is one typed JSON row that merges the post's text, timestamps, and author fields with the group's name, privacy, member count, and description, so there's no HTML to parse and no CSS selectors to maintain. After reading this, you'll know exactly which fields the Actor returns, how to filter posts by keyword, length, or author, and how to run it in monitoring mode so repeat runs only return new content.

What is the Facebook Group Posts And Details Scraper?

The Facebook Group Posts And Details Scraper is an Apify Actor that scrapes feed posts and group profile details from one or many public Facebook groups, either from group URLs you supply or from groups it discovers on your behalf from a list of keywords. It runs against Facebook's public, logged-out group feed and never authenticates — no Facebook account, password, or session cookie is used anywhere in the request pipeline.

• 📝 Scrape group feed posts — text, author, timestamps, and a direct post permalink
• 🏷️ Scrape group details — name, privacy, member count, description, and cover photo
• 🔎 Discover groups automatically from a list of keywords — no group URL required
• 🎛️ Filter posts by include/exclude keyword, minimum length, content type, or a single author ID
• 📦 Export as JSON, CSV, or any format the Apify dataset supports — no proxy setup required

What data does the Facebook Group Scraper collect?

Every dataset row combines three layers of data — the post itself, the person who wrote it, and the group it came from — plus metadata about how that group entered the run.

Data Type	Key Fields	JSON Field Names
Posts	text, permalink, publish date, raw timestamp	postText, postUrl, publishedAt, timestamp, id
Post authors	name, numeric ID, profile URL, first/last name, avatar	postAuthor, postAuthorId, postAuthorUrl, firstName, lastName, image
Group details	name, vanity slug, privacy, member count, description, cover photo	groupName, groupVanity, groupPrivacy, groupMemberCountText, groupDescription, groupCoverPhotoUrl, groupCreatedAt
Discovery metadata	which keyword(s) surfaced the group, how the group entered the run	discoveryKeywords, discoverySource

Need more Facebook data?

If you also need event listings, RSVPs, or engagement data instead of group posts, API-Empire publishes Facebook Events Scraper: Comments & Engagement Insights for that surface. Pair the two when a research or monitoring workflow spans both Facebook groups and Facebook events.

Why not build a Facebook group scraper yourself?

Facebook has no public API a developer can call to read posts or details from an arbitrary group. The closest thing that ever existed, Meta's Groups API, was deprecated starting with Graph API v19 in January 2024 and fully removed from every Graph API version on April 22, 2024 — and even before that, it only worked for groups an app itself administered, never for a public group you simply want to read (Sprinklr, Meta Deprecates Facebook Groups API, checked 2026-08-04). Building this yourself means reverse-engineering Facebook's GraphQL feed and its changing query IDs, rotating residential proxies, matching a real browser's request fingerprint, and re-doing all of that every time Facebook ships an update — ongoing maintenance work this Actor already absorbs.

Why do developers and teams scrape Facebook groups?

For AI engineers and agent builders

Facebook groups are dense, topic-specific discussion data that's awkward to get any other way. Point discoveryKeywords at a niche (e.g. a product category or support topic), pull postText, groupName, and publishedAt from every matching group, and index the result into a vector store for a RAG-backed support or research agent. Because every field is already typed JSON, an agent can call this Actor as a tool and consume the dataset directly — no HTML cleanup step between the scrape and the embedding model.

For marketers and brand teams

discoveryKeywords finds every group discussing a topic without you first knowing it exists, and keywords / excludeKeywords narrow the feed to posts that actually mention your brand or product while dropping sales-pitch noise. Combined with minPostLength, a brand team can build a daily feed of genuine community mentions across dozens of groups instead of manually checking each one, and re-run with monitoringMode on to see only what's new since the last check.

For researchers and analysts

Because the Actor only reads groups' anonymous, logged-out feed, everything it returns is content Facebook already shows to any visitor without an account — useful when a research design needs to stay strictly within publicly accessible data. startDate scopes a pull to a specific window (e.g. before/after an event), and groupMemberCountText and groupDescription give context about the community a set of posts came from without opening each group manually.

For developers building data products

discoveryKeywords plus maxGroupsPerKeyword turns a topic list into a structured directory of active groups and their profile data — a starting point for a group-discovery tool or a lead-gen product. monitoringMode persists seen post IDs per group between runs, so a scheduled run only pushes new posts, which is the shape a data product's incremental pipeline needs.

How to scrape Facebook groups with this Actor (step by step)

1. Open the Actor's page on the Apify Store, or find it in your Apify Console if you've already added it.
2. Provide at least one starting point — a group URL or ID in startUrls, a topic in discoveryKeywords, or both. The run needs at least one; leaving both empty stops the run with no results.
3. Set your filters — keywords, excludeKeywords, minPostLength, contentMode, authorIdFilter, maxPosts, sortOrder, and startDate all apply the same way regardless of whether a group came from startUrls or from discovery.
4. Start the run from the Console, or trigger it via the Apify API / apify_client.
5. Download results as JSON, CSV, or any other format the Apify dataset export supports once the run finishes.

What to do when Facebook changes its structure

Facebook periodically changes its GraphQL query IDs, feed markup, and anti-bot checks, and when it does, unmaintained scrapers start returning empty pages. This Actor is maintained against those changes, and the output schema documented below — field names and types — stays stable, so a pipeline built on top of it keeps working without changes on your end.

What changed in Facebook group scraping recently?

The most consequential recent change to Facebook's access model was Meta fully removing the Groups API from the Graph API: deprecated in v19 (announced around January 2024) and removed from every API version by April 22, 2024, closing off the last officially sanctioned way to read group content programmatically (Sprinklr, checked 2026-08-04). That followed a longer pattern: since Meta's 2018 platform review, group-related permissions for third-party apps have been steadily narrowed rather than expanded (TechCrunch, July 2, 2018). Independent write-ups on scraping Facebook also report Meta continuing to tighten anti-bot defenses on public pages through 2024–2025, with open-source scraping libraries breaking more often each year they aren't actively maintained (Scrapfly, checked 2026-08-04). For DIY scrapers this means rising maintenance overhead — GraphQL doc IDs and headers need re-discovery after each change. For users of this Actor it means no action required; it's maintained against these shifts. What remains reachable is unchanged: text posts, author name/ID/profile link, and group profile info on groups that are public and viewable while logged out — private groups and exact (non-rounded) member counts stay out of reach either way.

⬇️ Input

Parameter	Required	Type	Description	Example Value
startUrls	No	array	Facebook group URLs or bare group identifiers to scrape directly. Optional when discoveryKeywords is used instead — combine both to merge explicit groups with keyword-discovered ones in one run.	["https://www.facebook.com/groups/germtheory.vs.terraintheory"]
discoveryKeywords	No	array	Keywords/topics; each is resolved to matching Facebook groups, deduplicated across all keywords, and merged with startUrls. Leave empty to only use startUrls. A per-keyword coverage summary is saved to the run's key-value store as DISCOVERY_COVERAGE_SUMMARY.	["cheap meal ideas", "cooking recipes"]
maxGroupsPerKeyword	No	integer	Caps how many matching groups are kept per keyword during discovery. Minimum 1, maximum 20, default 5. Only applies when discoveryKeywords is used.	5
keywords	No	array	Only keep posts whose text contains at least one of these keywords (case-insensitive). Applies to every post regardless of whether its group came from startUrls or discovery. Leave empty to keep all posts.	["recipe", "meal prep"]
excludeKeywords	No	array	Drop any post whose text contains any of these keywords (case-insensitive). Leave empty to disable.	["for sale", "selling"]
minPostLength	No	integer	Only keep posts whose text is at least this many characters long. Minimum 0, default 0 (no minimum).	40
contentMode	No	string	Narrows results by content type. Enum: ALL (All posts), TEXT_ONLY (Text-only posts), ATTACHMENT_ONLY (Attachment-only posts). Default ALL.	"TEXT_ONLY"
authorIdFilter	No	string	Only keep posts from one specific member — enter their numeric postAuthorId. Leave empty to keep posts from every author.	"100003819380079"
monitoringMode	No	boolean	When enabled, the Actor remembers post IDs it has already seen and skips duplicates on future runs, using the Apify key-value store to persist state. Default false.	true
maxPosts	No	integer	Global cap across the whole run, across both startUrls and keyword-discovered groups. The cap is split across all resolved groups, results are merged, then capped at this value. Minimum 10, default 10.	50
sortOrder	No	string	Sorting strategy requested from the group feed. Enum: RECENT_POSTS (Recent posts), TOP_POSTS (Top posts), RECENT_ACTIVITY (Recent activity), CHRONOLOGICAL (Chronological). Default RECENT_ACTIVITY.	"RECENT_ACTIVITY"
startDate	No	string	Only scrape posts newer than this date. Format YYYY-MM-DD. Leave empty to scrape all available posts regardless of date.	"2026-01-01"
proxyConfiguration	No	object	Apify Proxy settings. Defaults to the Residential proxy group when left blank, which is recommended for reliability.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

Example input

{
  "startUrls": ["https://www.facebook.com/groups/germtheory.vs.terraintheory"],
  "discoveryKeywords": ["cheap meal ideas", "budget cooking"],
  "maxGroupsPerKeyword": 5,
  "keywords": ["recipe", "meal prep"],
  "excludeKeywords": ["for sale", "selling"],
  "minPostLength": 30,
  "contentMode": "ALL",
  "authorIdFilter": "",
  "monitoringMode": false,
  "maxPosts": 50,
  "sortOrder": "RECENT_ACTIVITY",
  "startDate": "2026-01-01",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

The most common input mistake is leaving both startUrls and discoveryKeywords empty — the run logs an error and exits with zero dataset rows, since the Actor needs at least one group to start from, whether given directly or found via a keyword.

⚠️ sortOrder changes which posts Facebook's own feed algorithm returns, but the Actor re-sorts every option except CHRONOLOGICAL into newest-first before saving — so RECENT_POSTS, TOP_POSTS, and RECENT_ACTIVITY end up in the same final order in the dataset even though Facebook may prioritize different underlying posts for each.

⬆️ Output

Results are pushed to the Actor's dataset one row per post, as typed, normalized JSON with a fixed set of keys — the schema below never changes shape between rows. From the dataset you can export to JSON, CSV, Excel, XML, or the other formats the Apify platform's dataset view offers.

Scraped post

{
  "id": "25346255468358122",
  "image": "https://scontent.xx.fbcdn.net/v/example_avatar.jpg",
  "postText": "Made this budget-friendly lentil soup for under $5, recipe in comments!",
  "postAuthor": "Jane Doe",
  "postAuthorId": "100048765312428",
  "postAuthorUrl": "https://www.facebook.com/profile.php?id=100048765312428",
  "firstName": "Jane",
  "lastName": "Doe",
  "timestamp": "1750760400",
  "publishedAt": "2025-06-24T10:20:00Z",
  "scrapedAt": "2026-08-04T09:00:00Z",
  "postUrl": "https://www.facebook.com/groups/cheapmealideas/posts/25346255468358122/",
  "groupUrl": "https://www.facebook.com/groups/cheapmealideas",
  "groupName": "Cheap Meal Ideas",
  "groupVanity": "cheapmealideas",
  "groupPrivacy": "Public group",
  "groupMemberCountText": "6M members",
  "groupDescription": "This group is open for anyone to join or share with others...",
  "groupCoverPhotoUrl": "https://scontent.xx.fbcdn.net/v/example_cover.jpg",
  "groupCreatedAt": null,
  "discoverySource": "keywordDiscovery",
  "discoveryKeywords": ["cheap meal ideas"]
}

• groupMemberCountText is Facebook's own rounded, formatted string (e.g. "6M members") — Facebook doesn't expose an exact member count to anonymous visitors, so there is no precise-integer version of this field.
• groupCreatedAt is null on every row. Facebook's anonymous group page doesn't expose the group's founding date to a logged-out visitor, and the Actor deliberately leaves it null rather than substituting a post date as a stand-in.
• discoverySource is one of startUrls, keywordDiscovery, or both (the group was supplied directly and also matched a discovery keyword).
• discoveryKeywords is an empty list for groups that only came from startUrls.

How does this Facebook Group Scraper compare to other Facebook scrapers?

Feature	This Actor	Generic alternative
Entity coverage	Posts, post authors, and group profile in one row	Usually posts only; group details need a separate scrape
Group discovery	Built-in keyword-to-group discovery, no URL required	Requires already knowing the group URL
Content filtering	Built-in include/exclude keyword, min-length, content-type, and author filters	Typically requires post-processing after the scrape
Output format	Typed, normalized JSON via the Apify dataset (JSON/CSV/Excel/XML)	Often raw HTML or inconsistent fields that still need parsing
Incremental runs	Monitoring mode skips previously-seen post IDs per group	Usually re-scrapes everything on every run

If you're building an AI agent or RAG pipeline, the output format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature.

How many posts can you scrape with this Facebook Group Scraper?

maxPosts has a minimum of 10 and no maximum in the input schema — there's no hard upper cap built into the Actor itself, only the platform limits described below. The cap is split evenly across every resolved group (explicit startUrls plus keyword-discovered groups), the per-group results are merged, and the merged list is trimmed back down to maxPosts — so with maxPosts: 50 across 5 groups, each group is targeted for roughly 10 posts. Within each group, the Actor pages Facebook's GraphQL feed by cursor, budgeting up to max(120, pages_needed + 80) pages, and stops early if 8 consecutive pages return no new posts or no cursor progress — Facebook's feed pages overlap heavily, so not every page yields new content. When monitoringMode or content filters are active, the Actor over-fetches (up to 2,500 raw posts per group) before filtering, since filtered-out or already-seen posts don't count toward the quota. Facebook itself can return empty or rate-limited pages that look automated, so hitting the full maxPosts on every single run isn't guaranteed.

Integrate this Facebook Group Scraper and automate your workflow

This Actor works with any language or tool that can send an HTTP request.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")
run = client.actor("facebook-group-posts-and-details-scraper-multi-keyword-filters").call(
    run_input={
        "startUrls": ["https://www.facebook.com/groups/germtheory.vs.terraintheory"],
        "maxPosts": 50,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["groupName"], "-", item["postAuthor"], "-", item["postText"][:60])

Works in Python, Node.js, Go, Ruby, cURL.

Automation platforms (n8n, Make, LangChain)

In n8n, the official Apify node's "Run Actor" operation can call this Actor by its ID with the same input JSON used above, and pass the resulting dataset items straight into any downstream n8n node. In Make, Apify's app module for running an Actor and fetching its dataset accepts the Actor ID and input, then feeds the returned posts into a Make scenario. In LangChain, Apify's dataset loader integration can load a finished run's dataset directly as documents for a RAG pipeline, using postText as page content and the remaining fields as metadata.

Is it legal to scrape Facebook groups?

Scraping publicly accessible Facebook content is generally lawful, but this Actor's output includes personal data — post author names, numeric IDs, profile links, and avatar images — so GDPR and CCPA rules about lawful basis, storage, and downstream use still apply to what you do with the results, even though the Actor itself only reads what a logged-out visitor can already see. It never accesses private or login-gated groups, and it doesn't authenticate as any Facebook user. Respect Facebook's Terms of Service for your own account activity, and don't use this data to re-identify or contact individuals in ways that violate applicable privacy law. Consult legal counsel for commercial use cases involving bulk personal data.

Frequently asked questions

Does this Facebook Group Scraper work without a Facebook account?

Yes. The Actor never logs in and never uses a Facebook account, password, or session cookie — it reads the same public group page and GraphQL feed a logged-out browser can reach. The only credential involved is an Apify Proxy configuration, which defaults to the Residential proxy group automatically.

How often is the scraped data updated?

Every run fetches live from Facebook — nothing is cached or reused between runs (unless monitoringMode is on, which intentionally skips post IDs already seen). Data reflects whatever Facebook's feed API returns at the moment the run executes.

What happens if a group is private, or a post gets deleted mid-run?

The Actor can only read a group's anonymous feed, so a private, closed, or login-gated group returns no usable group ID after 3 retries and is logged as "could not be fetched" and skipped — the rest of the run's groups continue unaffected. A post deleted between page loads simply doesn't appear in the results; it isn't flagged as an error row.

Can I scrape private or restricted Facebook groups?

No. Only groups that are public and viewable while logged out are returned. Private, closed, and login-gated groups are out of scope — the Actor has no login step to get past that wall.

Do I need to provide my own proxy?

No. proxyConfiguration defaults to Apify's Residential proxy group automatically when left blank, which the Actor's own input schema recommends for reliability. You can override it with your own proxy groups if you prefer.

Does this Actor work for AI agent workflows and LLM pipelines?

Yes. It's callable as an HTTP endpoint via the Apify API or apify_client from any agent framework, and every response is typed JSON with stable field names — no HTML and no parsing step before passing results to an LLM.

How does this Actor handle Facebook's anti-bot system?

It uses Apify's Residential proxy by default (with retried session setup), retries HTTP requests on connection failures and on 408/429/500/502/503/504 responses with backoff, retries a group's metadata fetch up to 3 times if Facebook doesn't return a usable group/document ID, and stops paging a stalled feed after 8 consecutive pages with no progress instead of looping indefinitely. Requests mirror a real Chrome browser's headers and Facebook's own GraphQL client request-serialization fingerprint. No CAPTCHA-solving or headless browser is used — it's a pure HTTP client.

How does this Facebook Group Scraper compare to other Facebook scrapers?

Compared with a typical Facebook group scraper, this Actor returns post, author, and group data in a single row rather than requiring a second scrape for group details, includes built-in keyword-to-group discovery, and applies content filters (keyword, length, content type, author) before the data ever leaves the run.

Does this Actor return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with stable field names — pass it directly into an LLM's context window, index it into a vector store, or route it through an agent tool without any HTML cleanup.

Can I use this Actor without managing proxies?

Yes. Apify's Residential proxy group is applied by default via the proxyConfiguration prefill, so you don't need to source, rotate, or pay for proxies separately unless you choose to supply your own.

What happens when Facebook changes its structure or blocks the scraper?

The Actor is maintained against Facebook's changes, and the output schema — the field names and types documented above — stays stable on your end, so integrations built on top of it don't need to change when Facebook does.

💬 Your feedback

Found a bug, or need a field that isn't here? We want to know. Use the Issues tab on this Actor's Apify Store page, or message the developer directly through Apify Console — that's also the fastest way to confirm whether a new Facebook layout change needs a fix on this Actor's side.