📡 Facebook Group Radar

Facebook Group Scraper — Discover, Score, Rank Groups & Leads

Facebook Group Radar is a Facebook group scraper that takes group URLs, numeric IDs, vanity handles, or search keywords, and returns each public group's About data, a derived 0–100 quality score, a rank, and — when you want it — the admins and moderators turned into enriched lead objects. It runs logged-out, with no Facebook cookies required. Every response is structured JSON, ready to pass directly to an LLM, index into a vector store, or feed a monitoring pipeline that tracks how a set of groups is trending. Point it at one group, a list of groups, or a handful of keywords, and get back a ranked, scored dataset instead of a flat dump of pages.

What is Facebook Group Radar?

Facebook Group Radar queries Facebook by group URL, group ID, group handle, container URL (a page that lists many groups, such as a group-search results page), or free-text keyword, and returns one scored, ranked record per group. It scrapes the group's public "About"/profile data — not posts or comments — logged-out, so it does not require a Facebook account, password, or cookie file. What sets it apart from a plain group profile scraper is that it computes a composite qualityScore from size, posting activity and admin/moderator governance, assigns every group a rank, and — when enrichLeads is on — converts admins and moderators into lead objects with a role, a profile-type classification, and (where derivable) a direct message URL.

• Group profile scraping — name, description, creation date, privacy (public/private), discoverability, and activity counts (posts today, posts last month, member count, new members) for any public group you point it at.
• Keyword and container-URL discovery — supply search terms or a Facebook groups-search URL instead of exact group links, and Radar extracts the group URLs it finds and scrapes each one.
• Quality scoring and ranking — every group gets a qualityScore (0–100) built from member count, posting activity, and admin/moderator count, and a rank field so the output arrives pre-sorted.
• Admin/moderator lead generation — turns the group's public admin and moderator facepile into lead records with a classified profile type and, for numeric-ID profiles, a direct messageUrl.
• Optional AI enrichment — an LLM call that classifies each group's niche and estimates lead quality from its name and description, across seven provider families.
• Include/exclude keyword filtering and a minimum-member floor — narrow the result set before it's ranked, not after.

What data can you get with Facebook Group Radar?

Facebook Group Radar returns three kinds of data in every pushed record: the group's profile facts, the derived metrics/ranking block, and (when enabled) the admin/moderator leads.

Result type	Extracted fields	Primary use case
Group profile	groupId, groupName, groupDescription, groupCreatedTime, groupUrl, sourceUrl, type, activity (newPostsToday, newPostsLastMonth, totalMembers, newMembersLastWeek), about (privacyInfo, discoverabilityInfo, history, tags), privacy	Identifying and cataloguing groups relevant to a niche or region
Metrics & ranking	metrics (memberCountNumeric, postsToday, postsLastMonth, postsPerDayAvg, engagementPer1kMembers, activityScore, qualityScore, ageDays, isPublic), plus the flattened top-level memberCountNumeric, qualityScore, activityScore, postsLastMonth, and rank	Sorting a candidate list of groups down to the ones worth joining, monitoring, or pitching
Admin/moderator leads	leads (name, role, url, profileId, profileType, messageUrl), leadsCount, plus the raw adminProfiles / moderatorsProfiles arrays	Turning group governance into an outreach list

Quality-scored ranking and admin/moderator leads

This is the pair of blocks that separates Radar from a plain group-page scraper: instead of a list of pages, you get a sorted list with a reason for the sort, and a name attached to every group's leadership. qualityScore is a 0–100 composite computed directly in the actor: a size component from log10(members + 1), an activity component from posts-per-day, and a governance component from the number of admins and moderators found on the page — each component capped before summing, so no single input can dominate the score. rank is assigned by sorting the scraped groups on whichever field rankBy selects. Every admin and moderator visible on the group's About/profile page becomes a lead:

{
  "leads": [
    {
      "name": "Jane Admin",
      "role": "admin",
      "url": "https://www.facebook.com/profile.php?id=100001234567890",
      "profileId": "100001234567890",
      "profileType": "numeric_id",
      "messageUrl": "https://www.facebook.com/messages/t/100001234567890"
    },
    {
      "name": "Community Mod",
      "role": "moderator",
      "url": "https://www.facebook.com/community.mod.handle",
      "profileId": "community.mod.handle",
      "profileType": "username",
      "messageUrl": null
    }
  ],
  "leadsCount": 2
}

messageUrl is only populated for numeric_id profiles, because that is the only profile-URL shape Facebook resolves to a working m.me/messages route. For username, pfbid, or unparseable profile URLs, messageUrl is null rather than a guessed link — the actor's source code explicitly avoids fabricating a profile ID from a non-numeric handle.

Keyword and container-URL discovery

Instead of supplying exact group links, you can pass searchQueries (free-text keywords) or drop a Facebook group-search URL into startUrls. Radar auto-detects container URLs (pages matching /groups/search, /search/groups, /groups/discover, /groups/feed, /groups/browse, or a /search/ URL containing "group"), fetches the page, and extracts every /groups/<id-or-slug> link actually present in the returned HTML — it does not invent group URLs that aren't in the page. Each discovered group is then scraped exactly like a direct startUrls entry, and the record it produces carries matchedQuery so you know which keyword or container URL found it.

Why not build this yourself?

Facebook does not expose a general-purpose public API for enumerating or scoring groups by keyword, so the realistic alternative to an actor like this is a custom scraper. Three things make that a bigger job than it looks: Facebook's group and About pages ship their data as embedded application/json script blocks nested several levels inside a require/__bbox structure that changes shape between the main group page and the About tab — Radar's extraction code walks both shapes and several fallback paths to assemble one consistent record. Second, Facebook aggressively gates logged-out traffic: a response under roughly 5 KB or containing facebook.com/login is treated as a login wall, and Radar retries through an escalating proxy chain (direct → Apify datacenter proxy group SHADER → Apify residential proxy) before giving up on a target. Third, timestamps and profile IDs are easy to get subtly wrong — Facebook's raw created_time is a Unix timestamp with no timezone marker, and the group's admin/moderator facepile mixes numeric Facebook IDs with opaque internal IDs that don't resolve to a real profile URL. Radar converts every creation time to an absolute UTC ISO-8601 string and only builds a profile.php?id= or messages/t/ link from an id that is actually numeric, rather than guessing. Maintaining that logic — and re-verifying it every time Facebook reshuffles its embedded JSON — is the ongoing cost a hand-rolled scraper takes on that a maintained actor absorbs for you.

How to scrape Facebook groups with Facebook Group Radar?

1. Open Facebook Group Radar on the Apify Console (or find it in the Apify Store) and click Try for free / Start.
2. Add one or more entries to startUrls — a full group URL, a bare numeric group ID, a group's vanity handle, or a container URL such as a group-search results page — and/or add free-text terms to searchQueries.
3. Set the real query controls: maxGroupsPerQuery (cap per keyword/container), minMembers (floor), keywords/excludeKeywords (include/exclude filters on name+description), rankBy (sort key), and enrichLeads (on/off for the leads block).
4. Click Start and let the run finish — Radar fetches each target's main page and About page, extracts and merges the embedded JSON, computes metrics, and ranks the result set.
5. Open the Output tab and download the ranked, scored dataset as JSON or CSV (or any other Apify-supported export format).

{
  "startUrls": ["https://www.facebook.com/groups/535363634111893", "https://www.facebook.com/search/groups/?q=packaging"],
  "searchQueries": ["terrain theory"],
  "maxGroupsPerQuery": 10,
  "minMembers": 500,
  "rankBy": "qualityScore",
  "enrichLeads": true
}

How to run multiple queries in one job

startUrls and searchQueries are both arrays — add as many group URLs, container URLs, and keywords as you want to a single run, and Radar deduplicates targets internally (a group discovered by two different keywords is only scraped once) before scraping and ranking the combined set together. There is no separate batch-run mode; one run with a longer input list is the supported way to cover more ground.

⬇️ Input

Facebook Group Radar takes group URLs/IDs/handles, container URLs, and/or search keywords — every field is optional, and an empty run (no startUrls, no searchQueries) simply produces no targets and exits without pushing any rows.

Parameter	Required	Type	Description	Example value
startUrls	No	array	Facebook group URLs, numeric group IDs, group vanity handles, or container URLs that list many groups. Container URLs are parsed for the group links they contain and each discovered group is then scraped. Default: empty.	["https://www.facebook.com/groups/535363634111893"]
searchQueries	No	array	Keywords Radar searches Facebook for, then scrapes whatever groups it finds. Logged-out group search is frequently gated behind a login wall in datacenter regions; when that happens the query is reported as blocked in the log. Default: empty.	["packaging suppliers", "terrain theory"]
maxGroupsPerQuery	No	integer (min 1, max 100)	Caps how many discovered groups are scraped per keyword / container URL. Default: 10.	10
minMembers	No	integer (min 0)	Groups whose parsed member count is below this are dropped from the output and the ranking. Default: 0 (keep all).	1000
rankBy	No	string enum: qualityScore, members, activityScore	Metric used to sort groups and assign the rank field. qualityScore = composite of size, activity and governance; members = raw member count; activityScore = average posts/day. Default: qualityScore.	"members"
keywords	No	array	Keep only groups whose name or description contains at least one of these (case-insensitive). Default: empty (no include filter).	["packaging"]
excludeKeywords	No	array	Drop any group whose name or description contains one of these (case-insensitive). Default: empty (no exclude filter).	["buy", "sell"]
enrichLeads	No	boolean	When on, admin & moderator profiles are turned into enriched lead objects. Turn off to skip the leads block. Default: true.	true
aiEnhancement	No	boolean	When on, an LLM reads each group's name + description and classifies its niche/topic and estimates lead quality. Requires an API key. Off = no AI, no extra cost. Default: false.	false
aiModel	No	string enum (26 values — see below)	Provider auto-detected from the model name prefix. Only used when aiEnhancement is on. Default: "claude-haiku-4-5".	"claude-haiku-4-5"
aiApiKey	No	string (secret)	API key for the selected provider. Only required when aiEnhancement is on. If left blank, Radar falls back to the provider's environment variable. Stored as a secret.	"sk-ant-..."
proxyConfiguration	No	object (Apify proxy configuration)	Proxy used for all Facebook requests. Facebook blocks datacenter IPs heavily; Radar falls back to Apify datacenter then residential proxies with retries if the first attempt looks like a login/redirect page. Default: no proxy.	{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }

aiModel accepts: claude-haiku-4-5, claude-sonnet-5, claude-opus-4-8, claude-fable-5, gpt-4o-mini, gpt-4o, gpt-4.1-mini, gpt-4.1, o3-mini, o1, gemini-2.0-flash-lite, gemini-2.0-flash, gemini-1.5-pro, gemini-2.5-flash, gemini-2.5-pro, grok-2-latest, grok-3-mini, grok-3, grok-beta, deepseek-chat, deepseek-reasoner, sonar, sonar-pro, sonar-reasoning, mistral-small-latest, mistral-large-latest. The provider is auto-detected from the prefix (claude-* → Anthropic, gpt-*/o1/o3-* → OpenAI, gemini-* → Google, grok-* → xAI, deepseek-* → DeepSeek, sonar* → Perplexity, mistral-*/ministral-*/codestral-*/magistral-*/pixtral-* → Mistral).

Example JSON input

{
  "startUrls": [
    "https://www.facebook.com/groups/535363634111893",
    "https://www.facebook.com/search/groups/?q=packaging"
  ],
  "searchQueries": ["terrain theory"],
  "maxGroupsPerQuery": 15,
  "minMembers": 500,
  "rankBy": "qualityScore",
  "keywords": [],
  "excludeKeywords": ["buy", "sell"],
  "enrichLeads": true,
  "aiEnhancement": false,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

Common pitfall: entries in startUrls must contain /groups/ — a bare Facebook profile, page, or non-group URL is not normalized and is skipped with a warning in the run log, not silently converted. Bare numeric strings and plain handle strings (letters, digits, ., _, -) are accepted and turned into https://www.facebook.com/groups/<value>, but a full URL with no /groups/ segment in it is rejected outright.

⬆️ Output

Results are pushed as typed, normalized JSON — one row per group that passed your filters, already sorted by rank. Download from the Output tab as JSON, JSONL, CSV, Excel, XML, HTML table, or via the Apify API — any format the Apify platform's dataset export supports.

Scraped results

[
  {
    "groupId": "990295388988357",
    "groupName": "Sustainable Packaging Suppliers Network",
    "groupDescription": "A community for buyers and suppliers of sustainable packaging materials.",
    "groupCreatedTime": "2023-07-04T04:26:17.000Z",
    "activity": {
      "newPostsToday": 4,
      "newPostsLastMonth": 376,
      "totalMembers": "23.7K members",
      "newMembersLastWeek": "212 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 July 4, 2023." },
      "tags": { "text": "Tags", "description": "" }
    },
    "adminProfiles": [{ "name": "Jane Admin", "url": "https://www.facebook.com/profile.php?id=100001234567890" }],
    "moderatorsProfiles": [{ "name": "Community Mod", "url": "https://www.facebook.com/community.mod.handle" }],
    "type": "group",
    "groupUrl": "https://www.facebook.com/groups/990295388988357",
    "sourceUrl": "https://www.facebook.com/groups/990295388988357",
    "metrics": {
      "memberCountNumeric": 23700,
      "postsToday": 4,
      "postsLastMonth": 376,
      "postsPerDayAvg": 12.53,
      "engagementPer1kMembers": 15.87,
      "activityScore": 12.53,
      "qualityScore": 71,
      "ageDays": 753,
      "isPublic": true
    },
    "leads": [
      {
        "name": "Jane Admin",
        "role": "admin",
        "url": "https://www.facebook.com/profile.php?id=100001234567890",
        "profileId": "100001234567890",
        "profileType": "numeric_id",
        "messageUrl": "https://www.facebook.com/messages/t/100001234567890"
      },
      {
        "name": "Community Mod",
        "role": "moderator",
        "url": "https://www.facebook.com/community.mod.handle",
        "profileId": "community.mod.handle",
        "profileType": "username",
        "messageUrl": null
      }
    ],
    "leadsCount": 2,
    "discovery": { "source": "search", "matchedQuery": "packaging suppliers" },
    "matchedQuery": "packaging suppliers",
    "scrapedAt": "2026-07-26T09:00:00.000Z",
    "rank": 1,
    "memberCountNumeric": 23700,
    "qualityScore": 71,
    "activityScore": 12.53,
    "postsLastMonth": 376,
    "privacy": "Public"
  },
  {
    "groupId": "535363634111893",
    "groupName": "Terrain Theory Discussion Group",
    "groupDescription": "",
    "groupCreatedTime": "2021-02-11T18:03:44.000Z",
    "activity": { "newPostsToday": 0, "newPostsLastMonth": 41, "totalMembers": "8,412 total members", "newMembersLastWeek": "" },
    "about": {
      "privacyInfo": { "text": "Private", "description": "Only members can see who's in the group and what they post." },
      "discoverabilityInfo": { "text": "Hidden", "description": "Only members can find this group." },
      "history": { "text": "History", "description": "" },
      "tags": { "text": "Tags", "description": "" }
    },
    "adminProfiles": [],
    "moderatorsProfiles": [],
    "type": "group",
    "groupUrl": "https://www.facebook.com/groups/535363634111893",
    "sourceUrl": "https://www.facebook.com/groups/535363634111893",
    "metrics": {
      "memberCountNumeric": 8412,
      "postsToday": 0,
      "postsLastMonth": 41,
      "postsPerDayAvg": 1.37,
      "engagementPer1kMembers": 4.87,
      "activityScore": 1.37,
      "qualityScore": 34,
      "ageDays": 1626,
      "isPublic": false
    },
    "leads": [],
    "leadsCount": 0,
    "discovery": { "source": "seed_url", "matchedQuery": null },
    "matchedQuery": null,
    "scrapedAt": "2026-07-26T09:00:41.000Z",
    "rank": 2,
    "memberCountNumeric": 8412,
    "qualityScore": 34,
    "activityScore": 1.37,
    "postsLastMonth": 41,
    "privacy": "Private"
  },
  {
    "groupId": "112233445566",
    "groupName": "Regional Packaging Buyers",
    "groupDescription": "Sourcing and packaging discussion for regional distributors.",
    "groupCreatedTime": "2024-01-09T00:00:00.000Z",
    "activity": { "newPostsToday": 1, "newPostsLastMonth": 19, "totalMembers": "1,204 members", "newMembersLastWeek": "" },
    "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": "" },
      "tags": { "text": "Tags", "description": "" }
    },
    "adminProfiles": [{ "name": "Regional Group Owner", "url": "https://www.facebook.com/profile.php?id=100009876543210" }],
    "moderatorsProfiles": [],
    "type": "group",
    "groupUrl": "https://www.facebook.com/groups/112233445566",
    "sourceUrl": "https://www.facebook.com/groups/112233445566",
    "metrics": {
      "memberCountNumeric": 1204,
      "postsToday": 1,
      "postsLastMonth": 19,
      "postsPerDayAvg": 0.63,
      "engagementPer1kMembers": 15.78,
      "activityScore": 0.63,
      "qualityScore": 26,
      "ageDays": 199,
      "isPublic": true
    },
    "leads": [
      {
        "name": "Regional Group Owner",
        "role": "admin",
        "url": "https://www.facebook.com/profile.php?id=100009876543210",
        "profileId": "100009876543210",
        "profileType": "numeric_id",
        "messageUrl": "https://www.facebook.com/messages/t/100009876543210"
      }
    ],
    "leadsCount": 1,
    "discovery": { "source": "search", "matchedQuery": "packaging suppliers" },
    "matchedQuery": "packaging suppliers",
    "scrapedAt": "2026-07-26T09:01:12.000Z",
    "rank": 3,
    "memberCountNumeric": 1204,
    "qualityScore": 26,
    "activityScore": 0.63,
    "postsLastMonth": 19,
    "privacy": "Public"
  }
]

Notes on fields that don't self-explain: memberCountNumeric, qualityScore, activityScore, postsLastMonth, and privacy are duplicated at the top level (in addition to living inside metrics/about) specifically so they render as columns in the Apify dataset table view. about.tags is always present with text: "Tags" but its description is never populated by the current extraction logic — treat it as a reserved field, not a bug in your integration. ageDays is null when groupCreatedTime could not be parsed from the page. When aiEnhancement is on and a key resolves, four more fields are merged in: aiNiche (string), aiTopics (array of up to 5 keyword strings), aiLeadQuality ("high" / "medium" / "low"), and aiReason (one sentence) — all null if the AI call fails or no key is available.

How can I use the data extracted with Facebook Group Radar?

• B2B / sales development reps: run searchQueries against your target niche, filter with keywords/excludeKeywords and minMembers, and feed leads[].url / leads[].messageUrl straight into outreach — profileType tells you which leads have a working message link versus which need manual follow-up.
• AI engineers and LLM developers: the actor's JSON output is grounding for an agent — issue a startUrls/searchQueries run via the Apify API, get back ranked, scored groups, and pass the array as context to a model instead of hand-summarizing pages.
• Market and community researchers: use qualityScore, activityScore, and memberCountNumeric across a keyword set to map which communities in a niche are actually active versus dormant, without opening each group manually.
• Growth and community managers: point Radar at your own group and at named competitor groups on a schedule to compare postsPerDayAvg, engagementPer1kMembers, and admin/moderator headcount over time.

📈 How do you monitor group rankings and leads over time?

Group monitoring here means re-running the same startUrls/searchQueries set on a schedule and diffing the output, since Radar itself has no built-in change-tracking — each run is a fresh snapshot. The fields worth diffing between runs are rank (did this group move up or down against the others in the set), metrics.qualityScore and its three inputs, memberCountNumeric, postsLastMonth (activity trend), and leadsCount (has the admin/moderator roster changed — a new admin is a new lead). A practical loop: schedule a run across a fixed keyword or group-URL set, keep the previous run's dataset, join the two runs on groupId, and alert when rank crosses a threshold you care about or when a new entry appears in leads that wasn't in the prior run. Set this up with an Apify schedule on this actor's saved input, and pull each run's dataset via the Apify API (client.actor("facebook-group-radar").last_run().dataset().list_items()) for the comparison step — Radar does not deliver diffs itself.

Integrate Facebook Group Radar and automate your workflow

Facebook Group Radar works with any language or tool that can send an HTTP request through the Apify API.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("facebook-group-radar").call(run_input={
    "startUrls": ["https://www.facebook.com/groups/535363634111893"],
    "searchQueries": ["packaging suppliers"],
    "rankBy": "qualityScore",
    "minMembers": 500,
    "enrichLeads": True,
})

for group in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(group["rank"], group["groupName"], group["qualityScore"], group["leadsCount"])

Scheduled monitoring and delivery

Save an input configuration in the Apify Console and attach an Apify schedule to run it daily, weekly, or on any cron expression, then pull each run's dataset through the API or an integration (Make, Zapier, Google Sheets, Slack, and others) to route results without polling manually.

Is it legal to scrape Facebook group data?

Scraping publicly visible Facebook group data is generally lawful — Facebook Group Radar runs logged-out and returns only what appears on a public group's page without requiring a login, matching what any visitor to that page can already see. Because the output includes admin and moderator names and profile URLs, treat the leads block as personal data subject to GDPR (if the data subjects are in the EU/EEA) and CCPA (if they are California residents): you need a lawful basis to process it, and unsolicited outreach built from it may separately be regulated by anti-spam law in your jurisdiction. The group-level metadata (name, description, member count, activity) is closer to business/public-record data and is governed primarily by Facebook's own Terms of Service rather than personal-data law. Bulk collection for AI training and targeted operational monitoring of a handful of groups carry different risk profiles — the latter is closer to how this actor's filtering (minMembers, keywords) is designed to be used. Consult your legal team for commercial use cases involving bulk data storage or outreach built on the leads block.

❓ Frequently asked questions

How many groups does Facebook Group Radar return per run?

There is no single fixed cap. Discovery via searchQueries or a container URL in startUrls is capped by maxGroupsPerQuery (default 10, maximum 100) per keyword or container; direct group URLs/IDs/handles added to startUrls are not capped by that setting — you get one row per valid target you supply, minus any dropped by minMembers, keywords, or excludeKeywords.

Does Facebook Group Radar extract admin and moderator leads?

Yes, when enrichLeads is true (the default). Every admin and moderator found on a group's About/profile page is returned in the leads array with name, role, url, profileId, profileType, and messageUrl. messageUrl is only populated when profileType is numeric_id; for username, pfbid, or unclassifiable profiles it is null rather than a guessed link.

How does Facebook Group Radar handle Facebook's anti-bot measures?

It detects a login/redirect page by response size and content (a response under roughly 5 KB, or one containing facebook.com/login, is treated as blocked rather than parsed) and escalates proxies on failure: direct connection first, then an Apify datacenter proxy group, then Apify residential proxy with up to three retries and a two-second backoff between attempts. If every attempt still looks like a login wall, that target is skipped and logged rather than returning fabricated or partial data.

What happens when a keyword search gets blocked?

Radar reports the query's status honestly in the run log — ok, empty, or blocked — rather than silently returning nothing. Logged-out Facebook group search is frequently redirected to a login wall from datacenter IP ranges; if you see blocked entries, switch to direct group URLs or container URLs (which are checked separately) and enable proxyConfiguration with a residential proxy group.

How is qualityScore calculated?

It's a 0–100 composite computed from three capped components: a size component from the member count (log10(members + 1) / 6 × 40, capped at 40), an activity component from posts-per-day (postsPerDayAvg / 5 × 40, capped at 40), and a governance component from admin/moderator count (admins × 4 + moderators × 2, capped at 20). Set rankBy to members or activityScore instead if you want to sort on a single raw metric rather than the composite.

Can I scrape private Facebook groups with Radar?

No. Radar runs logged-out with no cookies, so it can only retrieve what a public visitor sees. A private group's page typically returns no usable embedded JSON to a logged-out request (or is redirected to a login wall), which the actor reports as a blocked/empty target rather than returning incomplete data.

How do I use Facebook Group Radar to monitor groups over time?

Schedule the same input on a recurring Apify schedule, keep each run's dataset, and diff on groupId: compare rank, qualityScore, memberCountNumeric, postsLastMonth, and leadsCount between the current and previous run, and alert on the deltas that matter to you. Radar produces a fresh snapshot per run — it does not track history internally.

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

It is callable as an HTTP endpoint through the Apify API by any agent framework that can make a request and parse JSON — an agent can trigger a run with startUrls/searchQueries, poll or await the result, and use the ranked group/lead JSON as grounding context before answering. No MCP server has been verified for this actor specifically.

How does Facebook Group Radar compare to other Facebook group scrapers?

As observed on the Apify Store on 2026-07-26, apify/facebook-groups-scraper extracts group posts and comments (captions, reactions, top comments) rather than group profile metadata, and does not compute a quality score, rank, or admin/moderator leads. curious_coder/facebook-group-member-scraper extracts member profiles (not admins/moderators specifically) and requires you to supply your own Facebook login cookies via a browser extension; it does not score, rank, or discover groups by keyword. Neither competitor's listing documents group-level scoring, ranking, or an admin/moderator lead block — that combination is specific to Facebook Group Radar.

Can I use Facebook Group Radar without managing proxies or Facebook credentials?

Yes for credentials — Radar runs logged-out and never asks for a Facebook password or cookies. For proxies, Radar can run with no proxyConfiguration at all and will attempt a direct connection with an automatic fallback to Apify datacenter and then residential proxy groups on failure; you don't have to source or rotate proxies yourself, though enabling Apify residential proxy up front is recommended for more reliable access to search/container pages.

What API key do I need for AI enrichment?

Only if aiEnhancement is true. Supply a key for your chosen provider via aiApiKey, or leave it blank and set the matching environment variable on the actor's run (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY/GOOGLE_API_KEY, XAI_API_KEY/GROK_API_KEY, DEEPSEEK_API_KEY, PERPLEXITY_API_KEY/PPLX_API_KEY, or MISTRAL_API_KEY depending on aiModel). If no key resolves, the actor logs a warning and turns AI enrichment off for the run rather than failing it.

💬 Your feedback

Found a bug, a group page shape Radar doesn't parse correctly, or a field you need that's missing? Let us know through the Actor's Issues tab on the Apify Console, or message Scrapier support directly — reports like this are how the extraction logic gets updated when Facebook changes its page structure.