Facebook Group Profile Scraper

Facebook Group Scraper — Profile Data, Activity and Admin Contacts

The Facebook Group Profile Scraper turns any public Facebook group URL, username, or numeric ID into structured JSON: group name, description, creation date, member and posting activity, privacy and discoverability settings, and the names and profile links of every admin and moderator listed on the group's about page. It's built for community managers auditing their own groups, agencies vetting groups before a partnership pitch, and researchers comparing community activity at scale. No Facebook login or developer account is required — paste a group source and run.

What is Facebook Group Profile Scraper?

Facebook Group Profile Scraper is an Apify Actor that fetches a Facebook group's public main page and about page and returns one structured JSON record per group. It reads only what Facebook renders publicly for that group — it does not scrape posts, comments, or member lists, only the group-level profile record. No Facebook account, login, or session cookie is required; the actor requests the pages anonymously and falls back through Apify's proxy tiers if Facebook blocks the request.

• Discovery by direct input — paste a full group URL, a group username, or a numeric group ID; no keyword search or directory crawling.
• Core identifying fields — groupId, groupName, groupDescription, groupCreatedTime.
• Activity snapshot — posts today, posts in the last month, total members, and new members in the last week, exactly as Facebook's about page displays them.
• About-page signals — privacy (Public/Private) and discoverability (Visible/Hidden) status, plus the group's own "History" text.
• Admin/moderator roster — name and Facebook profile URL for every admin and moderator Facebook exposes on the about page.
• Bulk input, one dataset item per group — output as JSON, and CSV/Excel/XML through Apify's standard dataset export.

What data can I extract with Facebook Group Profile Scraper?

Every successfully scraped group produces one dataset record with the following 8 top-level fields — this is the actor's complete output, not a subset.

Field	Example Value	Use Case
groupId	"990295388988357"	Stable identifier for deduplication or re-scraping the same group later.
groupName	"Toronto Buy And Sell"	Human-readable label for reports, spreadsheets, and dashboards.
groupDescription	"A community marketplace for..."	Understand a group's stated purpose before monitoring or contacting it.
groupCreatedTime	"2023-07-04T04:26:17.000Z"	Segment groups by age — new vs. long-established communities.
activity	{"newPostsToday": 28, "newPostsLastMonth": 376, "totalMembers": "23.7K members", "newMembersLastWeek": "No new members in the last week"}	Gauge how active a group currently is before investing time in it.
about	{"privacyInfo": {...}, "discoverabilityInfo": {...}, "history": {...}, "tags": {...}}	Confirm whether a group is public/searchable and read its own history blurb.
adminProfiles	[{"name": "Jane Doe", "url": "https://www.facebook.com/profile.php?id=..."}]	Identify who to contact for partnership, moderation, or outreach requests.
moderatorsProfiles	[]	Identify secondary contacts responsible for day-to-day moderation.

Activity and engagement signals

The activity object is the decision-driving data attached to every record: newPostsToday and newPostsLastMonth (integers) show posting volume, totalMembers carries Facebook's own formatted member-count string (e.g. "23.7K members"), and newMembersLastWeek shows recent growth as Facebook phrases it (a count string, or a note like "No new members in the last week"). A common use case is filtering a list of candidate groups down to the ones that are actually active — a group with a large member count but zero recent posts and no new members is a poor target for outreach or partnership, while a group posting dozens of times a day is a live community worth prioritizing.

Identification and segmentation fields

groupId and groupCreatedTime let you de-duplicate groups across runs and segment them by age. about.privacyInfo.text (Public/Private) and about.discoverabilityInfo.text (Visible/Hidden) let you split a scraped list into groups anyone can see and join versus closed or unlisted ones — useful when only public, discoverable communities are relevant to a research or outreach list. Note that about.tags is present in every record's schema but is not currently populated by the extraction logic — it always returns an empty description.

Why not build this yourself?

Meta's Graph API does not expose arbitrary group profile data to third-party apps — the Groups API only returns data for groups where your own app has been added by a group admin, so it can't be used to look up an arbitrary public group you don't manage. Building this yourself means reverse-engineering Facebook's embedded page data: the about page ships its fields buried inside deeply nested require/__bbox GraphQL blocks embedded in <script type="application/json"> tags, not a stable public endpoint, and that structure shifts across Facebook's own page/region variants.

On top of the parsing problem, you need to detect and recover from Facebook's login/redirect walls, and escalate through proxy tiers when a request gets blocked — this actor's fetch layer already does that: it tries a direct request, then an Apify datacenter proxy, then an Apify residential proxy with up to three retries, checking each response for login-page signatures before accepting it. If you already have Facebook API access to groups your own app manages, the Graph API is the right tool. If you need profile data on public groups you don't administer, this actor covers that gap without you maintaining the parsing and proxy-escalation logic yourself.

How to use data extracted from Facebook?

Community managers and group admins

Run the actor against your own group's URL to get a machine-readable snapshot of what your about page currently shows: privacy/discoverability status, activity counts, and the exact admin/moderator roster Facebook lists. This is useful for confirming your group's settings are what you intend them to be, and for tracking your posted admin list against who should actually have those roles, without opening Facebook and reading the about tab manually.

Agencies auditing multiple groups

Feed a list of candidate group URLs — clients' groups, competitor communities, or partnership prospects — into startUrls in one run and get back one comparable JSON record per group. Sort the results by activity.totalMembers and activity.newPostsToday to rank groups by real activity before recommending which ones a client should join, sponsor, or benchmark against.

Market and community researchers

Scrape a set of niche-topic groups and compare groupCreatedTime, activity, and about.privacyInfo across the list to map how a topic's community landscape is structured — which groups are old and steady, which are new and growing, and which are public versus closed. This produces a structured dataset for spreadsheet analysis without manually visiting each group's about page.

AI agents and automated pipelines

Because the output is a flat, predictable JSON object per group, it drops directly into an agent tool or enrichment pipeline: an agent can take a group URL, call the actor, and reason over activity and about fields to decide whether a group is worth monitoring, or attach adminProfiles to a CRM record as the contact point for that community.

🔼 Input sample

The actor takes two inputs, only one of which is required.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Facebook group URLs (e.g. https://www.facebook.com/groups/123456789), usernames (e.g. groupname), or numeric group IDs (e.g. 123456789). Supports bulk input.	["https://www.facebook.com/groups/535363634111893"]
proxyConfiguration	No	object	Proxy behavior. If Facebook blocks the request, the actor falls back to datacenter proxy and then residential proxy (with retries).	{"useApifyProxy": false}

{
  "startUrls": [
    "https://www.facebook.com/groups/535363634111893",
    "buyandsellcanada",
    "123456789012345"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Pitfall: each entry in startUrls must resolve to an actual group — a full group URL containing /groups/, a bare username, or a numeric ID. A search keyword, a personal profile URL, or a Page URL is logged as unsupported and silently skipped: no dataset row is produced and no charge occurs for that item. Also note that proxyConfiguration is accepted in the schema, but the current code path always initializes and attempts to use an Apify residential proxy internally regardless of what you set here — there is no way to force a fully proxy-less run through this field.

🔽 Output sample

One dataset item per successfully scraped group, as typed JSON with a consistent 8-field schema. Export as JSON, CSV, Excel, or XML through Apify's standard dataset download options.

[
  {
    "groupId": "990295388988357",
    "groupName": "Toronto Buy And Sell",
    "groupDescription": "A community marketplace for buying and selling locally.",
    "groupCreatedTime": "2023-07-04T04:26:17.000Z",
    "activity": {
      "newPostsToday": 28,
      "newPostsLastMonth": 376,
      "totalMembers": "23.7K members",
      "newMembersLastWeek": "No new members in the last 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 on July 4, 2023"
      },
      "tags": {
        "text": "Tags",
        "description": ""
      }
    },
    "adminProfiles": [
      {
        "name": "Congrats You Win",
        "url": "https://www.facebook.com/profile.php?id=pfbid02C1fv5Eanj6DAWFZxNfSD7RzJGRuvRES2QPemXLgnX6sdvRshaPSzZ6jJqHeEo7L3l"
      }
    ],
    "moderatorsProfiles": []
  }
]

Only the row_result event is charged, and it fires once per group the actor successfully scrapes. Groups it fails to scrape — blocked requests, dead links, or non-group inputs — push no row and are not charged.

How do you filter and target specific groups?

This actor has no query, category, or location filters — its only real scoping control is the list you put in startUrls. Targeting is done entirely by choosing which group URLs, usernames, or IDs to include and how many of them to submit in a single run; each item is processed independently and sequentially (with a short delay between requests), so narrowing your input list is the only way to control run size and focus. There's no built-in way to discover groups by keyword — the actor only profiles groups you already know how to identify.

▶️ Want to try other Facebook scrapers?

Scraper Name	What it extracts
Facebook Groups Search Scraper With Group Profile Details	Searches for Facebook groups by keyword and returns group profile details for each match.
Facebook Group Post With Top Contributors Scraper	Group posts plus a leaderboard of each group's top contributors.
Facebook Group Sentiment & Lead Analysis Scraper	Group posts enriched with sentiment scoring and lead-analysis signals.
Facebook Posts Search Scraper	Public Facebook posts matching a search query.
Facebook User Search Scraper: Related Profiles & Pages	Facebook profiles and pages related to a searched user.
Facebook Marketplace: Listing Location Details Scraper	Facebook Marketplace listings with location details.

How to extract Facebook data programmatically

The actor runs as a standard Apify Actor: one API call starts the run, and structured JSON comes back from the resulting dataset — no browser or custom scraping infrastructure required on your side.

Python example

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("<your-username>/facebook-group-profile-scraper").call(
    run_input={
        "startUrls": ["https://www.facebook.com/groups/535363634111893"],
        "proxyConfiguration": {"useApifyProxy": False},
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["groupName"], item["activity"]["totalMembers"], item["adminProfiles"])

Export to spreadsheets or CRM

Download the dataset as CSV directly from the Apify Console or API and import it into a spreadsheet or CRM. Map groupId to a Group ID column, groupName to Group Name, activity.totalMembers to a Members column, and adminProfiles[0].url to an Admin Contact URL column for an outreach or partnerships list.

Is it legal to scrape Facebook groups?

Yes — scraping publicly visible Facebook group pages is generally lawful, since these pages are published for anyone to view without logging in. Fields like groupName, groupDescription, activity, and about describe a public group, not an individual, and are best treated under Facebook's Terms of Service rather than personal-data law. adminProfiles and moderatorsProfiles, however, contain the names and profile URLs of identifiable individuals — that is personal data under GDPR and CCPA, and storing or reusing it requires a lawful basis. Consult legal counsel for commercial applications involving bulk storage of personal data.

❓ FAQ

Does this scraper return group posts, comments, or member lists?

No. It returns one profile-level record per group — name, description, creation date, activity counts, about-page settings, and the admin/moderator roster. It does not scrape individual posts, comments, or the full member list.

What happens if a group is deleted or made private after I last scraped it?

The actor returns whatever is currently public at request time. If a group's about page no longer exposes a field (or the group has been deleted, or is now unreachable without membership), that field comes back empty in the record, or — if no usable page data can be recovered at all — no row is pushed for that group.

Can I get admin and moderator contact details along with the group profile?

Yes. adminProfiles and moderatorsProfiles each return a name and Facebook url for every admin/moderator Facebook lists on the about page. Only what's publicly listed there is returned — no email addresses or phone numbers, since Facebook doesn't expose those on the public about page.

How accurate is the member and activity data?

The actor returns the activity and member-count figures exactly as Facebook's own about page displays them at request time — including Facebook's formatted strings like "23.7K members". Accuracy depends entirely on how current Facebook's own displayed numbers are; re-run the actor to refresh a stale figure.

How many groups can I scrape per run?

There's no hard-coded limit in the input schema — startUrls accepts as many entries as you add. Groups are processed one at a time in sequence, with a short delay between each request.

Can I target a group using just its username or numeric ID instead of a full URL?

Yes. startUrls accepts a full group URL, a bare username (e.g. groupname), or a numeric group ID (e.g. 123456789) — the actor normalizes any of the three into a group URL before scraping.

What happens if Facebook blocks the request?

The actor retries automatically: it first attempts a direct request, then escalates to an Apify datacenter proxy, and finally to a residential proxy with up to three retries, checking each response for login/redirect-page signatures before accepting it as real data.

Does Facebook Group Profile Scraper work with Claude, ChatGPT, and AI agent frameworks?

It's callable as a standard HTTP API endpoint by any agent framework capable of making an authenticated REST call — start the run, poll or wait for completion, then read the dataset items back as JSON.

Can I use this without a Facebook account or API key?

Yes. No Facebook login, cookie, or developer API key is needed — the actor requests pages anonymously. You only need an Apify account and API token to run the actor itself.

Conclusion

Facebook Group Profile Scraper turns any public Facebook group URL, username, or ID into a clean, consistent JSON record — name, description, activity, privacy status, and the admin/moderator roster — without a Facebook login or manual copy-pasting. It's built for community managers checking their own group, agencies and researchers comparing many groups at once, and any pipeline that needs structured group-profile data as input. Run it directly in the Apify Console, or call it from your own code with the Apify API to start extracting group profiles today.