Facebook Groups Posts Scraper

Facebook Groups Scraper — Extract Posts, Authors and Comments

Facebook Groups Scraper extracts public posts from any Facebook group into structured JSON — post text, media, timestamps, and engagement counts — along with the author profile embedded on every post and an optional real top-comments preview. Every response is typed, normalized JSON: no HTML, no CSS selectors, no headless-browser parsing required on your side. After reading this page you'll know exactly what fields the actor returns, how to run it, and how to wire it into a script, a scheduled pipeline, or an AI agent.

What is Facebook Groups Scraper?

Facebook Groups Scraper is an Apify Actor that collects posts from public Facebook groups by replaying Facebook's own internal feed-pagination query rather than rendering pages in a browser. Point it at one or more group URLs, usernames, or keywords, and it returns each post's text, author, timestamp, permalink, attachments, and engagement counts, plus three opt-in enrichments (full-resolution photo/OCR, group profile metadata, and a top-comments preview). No Facebook account or login is required — it collects only what an anonymous, logged-out viewer of the group can see.

• Scrape post text, media, timestamps, and engagement counts from public groups
• Capture the post author's profile (ID, name, profile URL, picture) on every row
• Attach a bounded, real top-comments preview per post (opt-in)
• Attach one-time group profile metadata — members, privacy, creation date, admins (opt-in)
• Export results as JSON, CSV, or Excel directly from the Apify dataset

What data does Facebook Groups Scraper collect?

The actor returns one row per post, with the post author's profile embedded on every row and two further entity types available as opt-in enrichments.

Data Type	Key Fields	JSON Field Names
Group posts	text, permalink, timestamp, attachments, engagement	text, url, date, attachments, likesCount, commentsCount
Author profiles	author ID, display name, profile URL, avatar	user.id, user.name, user.profileUrl, user.profilePic
Group profile metadata (opt-in)	member count, privacy, discoverability, creation date, admins	groupProfile.activity.totalMembers, groupProfile.about.privacyInfo, groupProfile.groupCreatedTime, groupProfile.adminProfiles
Top comments preview (opt-in)	comment text, comment author, comment date	topComments[].text, topComments[].authorName, topComments[].date

Need more Facebook data?

If you also need posts from public Facebook Pages rather than Groups, Facebook Page Posts Scraper covers that surface with the same JSON-first approach. If your project is about ad intelligence instead of organic posts, Facebook Ads Library Scraper pulls structured data straight from Meta's Ad Library. Both are separate Actors under this account, built the same way as this one.

How does Facebook Groups Scraper differ from the official Facebook API?

Meta's Graph API does expose some Facebook data, but access to group content is gated behind an app-review process and is generally limited to data a group's own admin can authorize — it is not designed to let an arbitrary third party pull posts from a public group they don't administer. Facebook Groups Scraper instead reproduces the same feed-pagination request Facebook's own web client makes to a public group page, so it works for any group your input can reach as a logged-out viewer.

Feature	Facebook Graph API	Facebook Groups Scraper
Access process	Requires app review / permission grant from Meta	No app review — run directly on Apify
Group content scope	Effectively limited to groups you administer or have been granted access to	Any public group reachable by an anonymous viewer
Setup	OAuth app registration, permission requests, review wait	Provide a group URL/username and run
Output format	Raw Graph API JSON per endpoint	Normalized, flat JSON per post, consistent across groups
Entity coverage	Varies by granted permission scope	Posts, author profiles, group metadata, and a comments preview in one run

Use the Graph API when you administer the group and need an officially sanctioned integration tied to your own app. Use Facebook Groups Scraper when you need structured post data from public groups you don't administer, without an app-review cycle.

Why do developers and teams scrape Facebook groups?

For AI engineers and agent builders

Facebook group posts are a source of unstructured, community-generated text — product complaints, symptom discussions, local recommendations — that's useful as retrieval context for a RAG pipeline or as raw material for fine-tuning a domain-specific classifier. Because every post arrives as typed JSON with stable field names (text, date, user.name, likesCount), it can be indexed into a vector store or passed straight into an LLM context window without a scraping-and-cleaning step in the agent loop.

For marketers and brand teams

Public groups are where a lot of unprompted brand and product discussion happens outside of a company's own channels. Pulling text, likesCount, commentsCount, and the optional topComments from a competitor's or an industry's community group lets a marketing team track sentiment and recurring complaints over time, using sortBy: RECENT_ACTIVITY to catch fresh discussion as it happens rather than waiting on manual monitoring.

For researchers and analysts

Academic and market researchers use public Facebook groups as a data source for studying community behavior, discourse patterns, or the spread of a topic over time — scope limited to what a group already makes visible to any logged-out visitor. Pairing date and text across a group's full post history (via maxPosts and sortBy: CHRONOLOGICAL) supports building a time-ordered dataset for trend or discourse analysis without manual scrolling and copy-paste.

For developers building data products

Teams building a monitoring dashboard, a research tool, or a data product on top of Facebook group activity can call this Actor on a schedule and feed its JSON output directly into their own database or pipeline. Because the schema is stable across runs, a scheduled job that stores id, date, likesCount, and commentsCount per post can build a rolling engagement history without re-deriving parsing logic each time Facebook tweaks its page markup.

How to scrape Facebook groups (step by step)

1. Open Facebook Groups Scraper on its Apify Store listing and click Try for free / Start.
2. Add one or more group URLs, usernames, or keywords to the startUrls input.
3. Set maxPosts (10–10,000 per group) and pick a sortBy order — ALL combines three sort strategies for maximum coverage.
4. Start the run.
5. Export the results from the Apify dataset as JSON, CSV, or Excel, or read them programmatically via the API.

What to do when Facebook changes its structure

Facebook Groups Scraper is actively maintained, and its output schema is designed to stay stable even when Facebook changes its internal page structure or query shape — field names and types on your end don't change as a result of an update on our side. No specific turnaround time is promised for any given fix.

⬇️ Input

startUrls is the only required field. Every other input has a documented default and can be left as-is for a first run.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	One or more Facebook group URLs, usernames, or keywords	["https://www.facebook.com/groups/cheapmealideas/"]
maxPosts	No	integer	Posts to collect per group (minimum 10, maximum 10,000, default 10)	20
sortBy	No	string (enum)	Post ordering: ALL, TOP_POSTS, CHRONOLOGICAL, or RECENT_ACTIVITY (default ALL)	"ALL"
resolveFullMedia	No	boolean	Re-fetch each photo attachment's own permalink for a full-resolution image URL and real OCR text (default false)	false
includeGroupProfile	No	boolean	Fetch each group's profile once and attach it to every post from that group (default false)	false
maxComments	No	integer	Cap on real top-level comments attached per post, 0–50 (default 0, disabled)	5
proxyConfiguration	No	object	Proxy settings — custom URLs, then a selected Apify proxy group, then residential as guaranteed fallback	{"useApifyProxy": true}

Example JSON input

{
  "startUrls": ["https://www.facebook.com/groups/cheapmealideas/"],
  "maxPosts": 20,
  "sortBy": "ALL",
  "resolveFullMedia": false,
  "includeGroupProfile": false,
  "maxComments": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

The most common input mistake is expecting groupProfile, topComments, or attachments[].fullImageUrl/ocrText to already be populated — those fields stay null, empty, or at their base value until you explicitly turn on includeGroupProfile, maxComments, or resolveFullMedia.

⬆️ Output

Every run writes one row per post to the Apify dataset, exportable as JSON, CSV, or Excel. The post row always includes the author's profile; the group profile and comments preview appear only when their inputs are enabled.

Scraped group post

{
  "facebookUrl": "https://www.facebook.com/groups/germtheory.vs.terraintheory",
  "id": "UzpfSTEwMDA3NzI2ODMyNTcyOTpWSzoyNjEzODczMzc4MjQ0MzYxNg==",
  "feedbackId": "ZmVlZGJhY2s6MjYxMzg3MzM3ODI0NDM2MTY=",
  "user": {
    "id": "100077268325729",
    "name": "Mary Farrar",
    "profileUrl": "https://www.facebook.com/profile.php?id=100077268325729",
    "profilePic": "https://scontent.fcpq3-1.fna.fbcdn.net/v/t39.30808-1/example.jpg"
  },
  "date": "2026-02-18T23:15:41.000Z",
  "url": "https://www.facebook.com/groups/germtheory.vs.terraintheory/posts/26138733782443616/",
  "text": "Swedish Dish cloths. I'm thinking about buying some to replace paper towels. Are they really non toxic? Thanks so much!",
  "attachments": [
    {
      "__typename": "Photo",
      "photo_image": {
        "uri": "https://scontent.fcpq3-1.fna.fbcdn.net/v/t39.30808-6/example_photo.jpg",
        "height": 960,
        "width": 720
      },
      "__isMedia": "Photo",
      "url": "https://www.facebook.com/photo/?fbid=26138733782443617",
      "id": "26138733782443617",
      "ocrText": ""
    }
  ],
  "likesCount": 4,
  "commentsCount": 10,
  "source_group": "https://www.facebook.com/groups/germtheory.vs.terraintheory",
  "groupProfile": null,
  "topComments": null
}

Group profile metadata (opt-in via includeGroupProfile)

{
  "groupId": "1000772683257",
  "groupName": "Germ Theory vs Terrain Theory",
  "groupDescription": "A community for discussing natural health and wellness topics.",
  "groupCreatedTime": "2019-03-11T00:00:00.000Z",
  "activity": {
    "newPostsToday": 12,
    "newPostsLastMonth": 340,
    "totalMembers": "48K / 47,982 members",
    "newMembersLastWeek": "126 new members this week"
  },
  "about": {
    "privacyInfo": {
      "text": "Public",
      "description": "Anyone can see who's in the group and what they post."
    },
    "discoverabilityInfo": {
      "text": "Visible",
      "description": "Anyone can find this group."
    },
    "history": {
      "text": "History",
      "description": "Group created March 11, 2019"
    }
  },
  "adminProfiles": [
    {"name": "Jane Admin", "url": "https://www.facebook.com/profile.php?id=100000123456789"}
  ],
  "moderatorsProfiles": []
}

Top comments preview (opt-in via maxComments)

[
  {
    "id": "Y29tbWVudDoyNjEzODczMzc4MjQ0MzYxNl8xMjM0NTY3ODk=",
    "text": "Yes, we've used them for a year and they're great!",
    "authorName": "Alex Rivera",
    "authorProfileUrl": "https://www.facebook.com/profile.php?id=100001234567890",
    "date": "2026-02-19T08:03:12.000Z"
  }
]

How many results can you scrape with Facebook Groups Scraper?

maxPosts sets a per-group ceiling of 10 to 10,000 posts (default 10); there is no separate actor-wide cap, so the total results for a run are the sum of maxPosts across every group in startUrls. Internally, pagination runs across Facebook's own cursor-based feed query, and with sortBy: ALL the actor paginates three sort orders in parallel strategies to maximize unique posts collected before duplicates are filtered out and the maxPosts limit is reached. Coverage beyond that point depends on how many posts Facebook's anonymous-viewer pagination actually exposes for a given group and sort order — some groups or sort orders may return fewer posts than requested. No fixed benchmark run time is published for this Actor.

Integrate Facebook Groups Scraper and automate your workflow

Facebook Groups Scraper works with any language or tool that can send an HTTP request, since every run and its results are reachable through the standard Apify API.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("facebook-groups-posts-scraper-pay-per-events").call(
    run_input={
        "startUrls": ["https://www.facebook.com/groups/cheapmealideas/"],
        "maxPosts": 20,
        "sortBy": "ALL",
    }
)

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["text"], post["user"]["name"], post["likesCount"])

Works in Python, Node.js, Go, Ruby, cURL — any client that can call the Apify REST API with your API token.

Automation platforms (n8n, Make)

In n8n, Apify's community node can run this Actor as a workflow step and pass its dataset output directly into downstream nodes (a database write, a Slack alert, or an LLM node). In Make, the Apify app module can trigger a run and iterate over the returned posts inside a scenario — useful for a scheduled scenario that checks a group for new activity and routes matching posts elsewhere.

Is it legal to scrape Facebook groups?

Scraping publicly accessible Facebook group posts is generally permitted, but legality depends on how the data is used and stored, not just how it's collected. Facebook Groups Scraper only returns data visible to an anonymous, logged-out viewer of a public group — it does not use login credentials or bypass any privacy setting. Because the output includes personal data (author names, profile URLs, profile pictures, and commenter identities), any storage or downstream use of that data is subject to GDPR, CCPA, and similar data-protection regimes, which require a lawful basis for processing personal data. Consult legal counsel for commercial use cases involving bulk personal data.

Frequently asked questions

Does Facebook Groups Scraper work without a Facebook account?

Yes. It collects data as an anonymous, logged-out viewer using Apify Proxy (with a residential-proxy fallback tier); no Facebook login or cookies are required or accepted as input.

How often is the scraped data updated?

Data is fetched live from Facebook on every run — nothing is served from a stale cache of post content. A bootstrap cache of internal query identifiers is kept per group to speed up recovery after a transient block, but it does not cache post data itself.

What happens if a group has no new posts or returns zero results?

If Facebook's anonymous-viewer pagination returns no posts for a group (e.g., an inactive group, an over-restrictive sort order, or a temporary block), the run logs the issue and simply produces fewer rows for that group rather than fabricating data — check the run log for that group's specific outcome.

Can I scrape private Facebook groups?

No. Only groups and posts visible to a logged-out, public viewer are accessible. Private or closed groups that require membership approval to view content are out of scope.

Does Facebook Groups Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP endpoint through the Apify API from any agent framework or script. Every response is typed, normalized JSON with stable field names, so it can be passed directly into an LLM prompt or indexed into a vector store without an HTML-parsing step.

How does Facebook Groups Scraper handle Facebook's anti-bot defenses?

It uses a tiered proxy fallback (custom proxy, then a selected Apify proxy group, then residential proxy as the guaranteed final tier, with rotating retries), an HTTP/2 client built to match a real browser's fingerprint, and a persistent per-group bootstrap cache so a transient block on one group doesn't require re-resolving its query identifiers from scratch on a later run.

Does Facebook Groups Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with stable field names across every group and run — no HTML, no selectors, no parsing step required before passing it to an LLM context window or agent tool.

Can I use Facebook Groups Scraper without managing proxies?

Yes. The Actor manages its own proxy tiers (custom, selected Apify proxy group, and residential fallback) internally; you only need to leave proxyConfiguration at its default or select an Apify proxy group if you have a preference.

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

The Actor is actively maintained, and its output schema is built to stay stable across Facebook-side changes — field names and types on your end don't change as a result of a maintenance update. No specific turnaround time is promised for any given fix.

Your feedback

Found a bug, or a field that doesn't match what's documented here? We want to know. Reach out through this Actor's Apify Store page or Issues tab so it can be reviewed and fixed.