Facebook Public Group Posts Scraper

Collect facebook public group posts as structured data for community research, brand monitoring, and repeatable reporting. Supply accessible public group URLs and receive post text, authors, timestamps, media links, external URLs, permalinks, and engagement totals visible to signed-out visitors.

The Actor uses an anonymous US residential route. It does not ask for Facebook credentials, access private groups, scrape group members, or bypass audience restrictions.

What does Facebook Public Group Posts Scraper do?

Facebook Public Group Posts Scraper turns the public discussion feed of each supplied group into dataset records. It follows Facebook's structured feed pagination until it reaches your item limit or the public feed ends.

You can:

• collect posts from one or several numeric public group URLs;
• keep all visible posts or filter visible text by topic;
• keep only posts published after an ISO date or timestamp;
• schedule the same input for recurring community monitoring;
• export results to JSON, CSV, Excel, XML, or RSS through Apify;
• send finished datasets to a webhook or downstream data pipeline.

Each accepted post creates one dataset item. Filtering is applied before storage and charging for the item event.

Who is it for?

Community managers can review announcements, questions, and recurring themes across accessible groups.

Brand and market researchers can collect public discussions for qualitative analysis without copying pages manually.

Event and nonprofit teams can locate public registration, meeting, or volunteer announcements with searchTerms.

Data teams can schedule runs and load normalized records into a warehouse, spreadsheet, or dashboard.

Developers can call the Actor through the Apify API or expose it as a tool through Apify MCP.

This Actor is not intended for private-group research, member-list collection, login-only content, or personal-profile enrichment.

Why use this Actor?

• Purpose-built records: output is normalized around posts rather than raw page HTML.
• No user cookies: the production route is anonymous and does not accept Facebook login credentials.
• Useful monitoring filters: topic and publication-time filters reduce downstream processing.
• Bounded retries: transient transport, rate-limit, and session failures trigger limited retries and one residential session rotation.
• Honest failures: login shells, private groups, rejected feed documents, and unrecognized response shapes fail clearly instead of returning a misleading successful empty run.
• Standard Apify output: datasets work with exports, schedules, webhooks, integrations, API clients, and MCP.

Facebook controls the public response shape and feed ordering. No scraper can promise that every historical post is exposed to an anonymous visitor.

What Facebook group post data is extracted?

Field	Type	Description
postId	string	Facebook post identifier
postUrl	string	Canonical public post permalink
groupId	string	Numeric source group identifier
groupUrl	string	Canonical source group URL
author	object	Visible author ID, name, URL, and profile picture URL when exposed
text	string or null	Visible post text; media-only posts can be null
postedAt	string or null	ISO 8601 publication timestamp when exposed
engagement	object	Visible reaction, comment, and share totals
mediaUrls	string[]	Public image and video attachment URLs
externalUrls	string[]	External links found in text or attachments
scrapedAt	string	ISO 8601 extraction timestamp

Null values mean Facebook did not expose that field to the anonymous public response. Engagement totals reflect what was visible at scrape time and can differ from totals shown to a logged-in member.

How to scrape Facebook public group posts

1. Open the Actor in Apify Console.
2. Add one or more public URLs containing a numeric group ID, for example https://www.facebook.com/groups/1443890352589739/.
3. Choose maxItems for the maximum number of saved posts across all groups.
4. Optionally add searchTerms or a since timestamp.
5. Click Start.
6. Open the Dataset tab to preview, download, or integrate the records.

Start with a small limit when evaluating a new group. Once the public route returns useful records, increase the limit or create a schedule.

Input parameters

startUrls

Required. A list of public facebook.com/groups/<numeric-id>/ URLs. The Actor validates the source domain and numeric group ID before making paid proxy requests.

Vanity-only paths that do not contain a numeric ID are rejected. Copy a group URL that includes its numeric identifier.

maxItems

Optional integer from 1 to 5,000. The default is 100. This is a global saved-item limit across all supplied groups, not a limit per group.

searchTerms

Optional list of up to 20 terms, each up to 100 characters. Matching is case-insensitive and uses OR logic: visible post text must contain at least one term. An empty list keeps all posts.

since

Optional ISO 8601 date or timestamp. Posts with an exposed publication time earlier than this value are skipped. Posts without an exposed timestamp are also skipped when this filter is active.

Example monitoring input:

{
  "startUrls": [
    { "url": "https://www.facebook.com/groups/1443890352589739/" }
  ],
  "maxItems": 100,
  "searchTerms": ["registration", "community event"],
  "since": "2025-01-01T00:00:00.000Z"
}

Output example

A current production-shaped dataset record looks like this after removing personal values:

{
  "postId": "1234567890123456",
  "postUrl": "https://www.facebook.com/groups/123456789012345/posts/1234567890123456/",
  "groupId": "123456789012345",
  "groupUrl": "https://www.facebook.com/groups/123456789012345/",
  "author": {
    "id": "pfbid0ExamplePublicIdentifier",
    "name": "Example Author",
    "url": null,
    "profilePictureUrl": null
  },
  "text": "Registration is now open for our community event.",
  "postedAt": "2025-01-15T12:00:00.000Z",
  "engagement": {
    "reactions": 12,
    "comments": 3,
    "shares": 1
  },
  "mediaUrls": [],
  "externalUrls": ["https://www.example.org/community-event"],
  "scrapedAt": "2025-01-15T12:05:00.000Z"
}

The default dataset contains only accepted post records. There are no separate author or media datasets and no separate charge events for nested author, engagement, link, or media fields.

How much does it cost to scrape Facebook public group posts?

The Actor uses pay-per-event pricing:

• a one-time Start event is currently $0.005 per run;
• each saved Item processed event is tiered by your Apify plan;
• the current BRONZE item price is $0.0022 per saved post.

At the current BRONZE tier, approximate Actor charges are:

Saved posts	BRONZE price calculation
5	$0.005 + (5 × $0.0022)
25	$0.005 + (25 × $0.0022)
100	$0.005 + (100 × $0.0022)

Residential proxy and compute consumption are covered by the event pricing. A filter can make the Actor inspect more source posts than it saves, but only saved records emit the item event. Your Apify plan and active tier determine the exact item price shown in Console before a run.

Community and brand monitoring workflows

Recurring topic monitoring

Set searchTerms, add a conservative since date, and schedule the Actor daily or weekly. Send the dataset to a webhook, database, or diff process. Store the newest postedAt value in your own workflow and use it for the next run.

Public announcement research

Search for terms such as registration, meeting, or volunteer. Export the retained posts to a spreadsheet with source permalinks so analysts can review context.

Multi-group collection

Supply multiple numeric public group URLs and one global item limit. The Actor processes groups in input order. Use separate runs when each group needs its own strict quota or schedule.

Data pipeline ingestion

Use the dataset API after the run finishes. Stable camelCase fields make it straightforward to map records into a warehouse table, search index, or language-model analysis step.

Use the Actor with the Apify API

Replace YOUR_TOKEN with an Apify API token. Keep tokens in a secret manager rather than source control.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~facebook-group-posts-scraper/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.facebook.com/groups/1443890352589739/"}],
    "maxItems": 10
  }'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/facebook-group-posts-scraper').call({
  startUrls: [{ url: 'https://www.facebook.com/groups/1443890352589739/' }],
  maxItems: 10,
  searchTerms: ['registration'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/facebook-group-posts-scraper").call(
    run_input={
        "startUrls": [
            {"url": "https://www.facebook.com/groups/1443890352589739/"}
        ],
        "maxItems": 10,
        "since": "2025-01-01T00:00:00.000Z",
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

For asynchronous pipelines, start a run without waiting and poll the run endpoint or configure a run-finished webhook.

Use Facebook group posts through MCP

Claude Code

Add this Actor to Claude Code through Apify MCP:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/facebook-group-posts-scraper"

Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use equivalent JSON configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/facebook-group-posts-scraper"
    }
  }
}

Example prompts:

• “Collect five posts from this accessible public Facebook group and summarize the topics.”
• “Find public posts containing registration or volunteer and return their source links.”
• “Run the Facebook group monitor for posts since 2025-01-01 and save the dataset URL.”

MCP follows the same input rules and public-only limitation as Console and API runs.

Tips for reliable runs

• Verify that the URL opens as a public group and contains /groups/<numeric-id>/.
• Begin with maxItems between 3 and 10 before scaling a new source.
• Use narrow searchTerms only when you expect matching text; zero saved records can be a valid filter result after a recognizable feed is loaded.
• Prefer a full ISO timestamp with Z when workflows compare runs across time zones.
• Split unrelated groups into separate scheduled tasks when they need different filters or quotas.
• Save post permalinks as the durable review link. Facebook CDN media URLs can expire.

The Actor automatically uses a sticky US residential session, retries transient failures with bounded backoff, and rotates once when needed. Users do not need to configure or supply proxy credentials in the input.

Limitations

• Only accessible public Facebook groups are supported.
• Private, hidden, login-required, age-gated, and geography-restricted feeds are outside scope.
• Group URLs must contain a numeric group ID; vanity-only paths are rejected.
• Facebook decides feed ordering, retention, and fields exposed to signed-out visitors.
• When searchTerms or since is active, each group is scanned for at most two public feed pages. This keeps filtered monitoring bounded, so a high maxItems value can return fewer matching posts.
• The Actor does not scrape comments, group members, private profiles, or reaction identities.
• Visible engagement can be missing or differ from a logged-in view.
• Author profile URLs and profile images are sometimes omitted in anonymous responses.
• Media CDN URLs can be temporary; download permitted media promptly if your workflow requires durable files.
• Internal Facebook response changes can temporarily require an Actor update.

A first-page response without a recognizable public post feed fails non-zero. Later pagination ends normally when Facebook reports no next cursor.

Responsible use and legality

Use this Actor only for data you are legally entitled to collect and process. Public visibility does not remove obligations under Facebook's terms, copyright rules, privacy law, data-protection law, or local regulations.

Do not use output for harassment, discrimination, surveillance of vulnerable people, identity profiling, or attempts to infer sensitive personal attributes. Minimize retained personal data, document a lawful purpose, restrict access, honor deletion requirements, and apply appropriate retention periods.

This Actor does not provide legal advice. Consult qualified counsel for regulated, high-risk, or large-scale uses.

Troubleshooting

“Use a public Facebook group URL containing its numeric group ID”

The supplied URL is not a supported facebook.com/groups/<numeric-id>/ address. Find a URL that includes the group's numeric ID and try again.

“Facebook returned no recognizable public post feed”

The group may be private, inaccessible to signed-out visitors, empty, restricted, or temporarily returning a challenge. Confirm public accessibility and retry later. Do not add Facebook cookies; the Actor intentionally has no credential input.

The run succeeded with zero dataset items

If a recognizable feed loaded, your searchTerms or since filter may have excluded every post. Remove the filters and test with a small limit.

Some engagement or author fields are null

Facebook did not expose those values in the anonymous response. Null is intentional and preferable to fabricated data.

A run stopped after retries

Inspect the log for an HTTP, rate-limit, or GraphQL response error. The Actor retries transient failures and rotates the residential session once; persistent upstream rejection is reported rather than hidden.

Related tools and integrations

This Actor is intentionally standalone because the current Automation Lab portfolio does not have a closer public-Facebook companion that adds a truthful adjacent workflow. Combine its default dataset with Apify Schedules, Webhooks, Google Sheets, Slack, Zapier, Make, or your own database pipeline.

If you need comments, private-group content, member lists, or authenticated profile data, do not treat this Actor as an equivalent solution. Those workflows require different permissions and product boundaries.

FAQ

Does it need my Facebook login or cookies?

No. It uses an anonymous public-data route and does not accept Facebook credentials.

Can it scrape private Facebook groups?

No. Private and login-only groups are explicitly excluded.

Can I scrape several groups in one run?

Yes. Add up to 100 supported URLs. maxItems applies across the entire run and groups are processed in input order.

Does searchTerms search Facebook globally?

No. It filters visible post text retrieved from the supplied groups. It does not discover groups or run a Facebook-wide search.

Are comments included?

No. The output contains the visible comment count when available, not comment bodies or authors.

Why does a filtered run inspect more posts than it saves?

Filtering happens after the public feed response is parsed. The Actor scans at most two public feed pages per group when filters are active, while item events are emitted only for saved records.

Can I schedule incremental monitoring?

Yes. Schedule the Actor and set since to the last timestamp your workflow processed. Apify schedules do not automatically rewrite input, so update the timestamp in your task or downstream automation when strict incrementality matters.

Is every historical post guaranteed?

No. Facebook controls what its anonymous feed exposes and in what order. Treat output as the publicly observable feed at run time, not a complete archival export.