# Facebook Groups Search Scraper (`scraper-engine/facebook-groups-search-scraper`) Actor

🔎 Facebook Groups Search Scraper extracts group search results—names, links, member counts, categories, keywords & engagement. 🚀 Ideal for market research, community discovery, lead gen and outreach. 📤 Fast, accurate, easy export to CSV/JSON.

- **URL**: https://apify.com/scraper-engine/facebook-groups-search-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 290 total users, 68 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Facebook Groups Search Scraper — Members, Posts and Visibility

Facebook Groups Search Scraper turns a keyword or a list of group URLs into structured JSON for every public Facebook group it finds — name, `memberCountNumeric`, `postsPerDayNumeric`, visibility, and 13 more fields per group. No login required: it searches DuckDuckGo for matching groups, then reads each group's public About page. Results stream to the dataset as JSON or CSV in real time. Try it now with a keyword like "photography" and see live results.

### What is Facebook Groups Search Scraper?

Facebook Groups Search Scraper is an Apify Actor that discovers public Facebook groups from a keyword and extracts each group's public About-page data — name, member count, post activity, visibility, and description — as structured JSON. It runs without a Facebook login or session cookie, working only from what a logged-out visitor can see on a group's About page. It's built for marketers, community managers, researchers, and developers who need group-level metadata at scale without manually searching Facebook.

### What Facebook group data is publicly available to scrape?

A group's About page exposes its name, visibility, description, and activity summary to any visitor without logging in. What's behind a login wall is the group's actual content and membership.

| Data Category | Publicly Available | Restricted behind login/group membership |
| --- | --- | --- |
| Group name, URL, profile picture | Yes | — |
| Visibility label (Public/Private) | Yes, when Facebook renders a privacy label | — |
| Group description | Yes (og:description meta tag) | — |
| Discoverability setting | Yes | — |
| Member count (text/number) | Yes, when shown on the About page | Exact, browsable member list — requires membership |
| Post-activity summary (posts/day, /month) | Yes, when shown on the About page | Individual post content and comments — requires membership |
| Join state (e.g. can-join status) | Yes, when present | Actually joining or posting — requires login |
| Member list / individual members | No | Requires being a logged-in group member |

Facebook Groups Search Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### What data can I extract with Facebook Groups Search Scraper?

Each dataset row is one Facebook group, described by identity fields, membership/activity metrics, and a scrape timestamp.

| Field Name | Description |
| --- | --- |
| `query` | The originating search keyword, or `"direct_urls"` for groups added as direct links |
| `id` | Facebook group ID extracted from the page HTML, when present |
| `name` | The group's name, parsed from the page's `og:title` meta tag |
| `url` | Canonicalized Facebook group URL |
| `profilePictureUri` | URL of the group's cover/profile image, from the `og:image` meta tag |
| `visibility` | `"Public"` or `"Private"`, parsed from the group's privacy label; `null` if no privacy label was found — never defaulted |
| `groupDescription` | The group's public description, from the `og:description` meta tag |
| `discoverabilityText` | The group's discoverability setting as shown on Facebook, e.g. "Anyone can find this group" |
| `type` | Static entity-type label, always `"Group"` |
| `viewerJoinState` | Join availability parsed from the page (e.g. `"CAN_JOIN"`); `null` if not present |
| `sourceType` | Whether the row came from a keyword search (`"keyword"`) or a pasted URL (`"directUrl"`) |
| `memberInfo` | Member-count text as shown on the About page (e.g. "22,345 total members"); `"Unknown members"` if not found |
| `memberCountNumeric` | Numeric member count parsed out of `memberInfo`; `null` if it can't be parsed |
| `postFrequency` | Human-readable posting-activity summary derived from the group's daily/monthly post counts (e.g. "5.2 posts a day"); `"Unknown posts"` if not found |
| `postsPerDayNumeric` | Numeric posts-per-day rate computed from the same post-count data |
| `postsPerMonthNumeric` | Raw count of posts in the last 30 days, from the About page |
| `scrapedAt` | UTC ISO-8601 timestamp of when the row was scraped |

#### Group identity & discovery fields

`query`, `id`, `name`, `url`, `profilePictureUri`, `visibility`, `groupDescription`, `discoverabilityText`, `type`, `viewerJoinState`, `sourceType`

#### Membership & activity metrics

`memberInfo`, `memberCountNumeric`, `postFrequency`, `postsPerDayNumeric`, `postsPerMonthNumeric`

#### Run metadata

`scrapedAt`

#### 🤖 Add-on: Need additional Facebook data?

Facebook Groups Search Scraper finds and profiles groups — it doesn't pull the posts inside them. Pair it with **Facebook Group Post Scraper** once you have a group URL, to extract that group's posts, comments, and engagement data. If you also need marketplace listings, **Facebook Marketplace Scraper** covers titles, prices, and seller info, and **Facebook Posts Scraper** extracts Page timelines with reaction breakdowns.

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

Meta's Graph API does not offer third-party apps an endpoint to search or discover public Facebook groups by keyword — group-related access is scoped to groups an app or user already has an approved relationship with. Facebook Groups Search Scraper instead searches by keyword directly and returns any matching public group it can find.

| Feature | Facebook Graph API | Facebook Groups Search Scraper |
| --- | --- | --- |
| Discover groups by keyword | Not available to third-party apps | Yes — search any keyword |
| Direct group lookup | Requires the app/user to already have access to that group | Yes — paste any public group URL |
| Approval process | Requires Meta App Review for group-related permissions | None — runs directly on Apify |
| Authentication | OAuth token tied to a Facebook user or app | None — reads only what a logged-out visitor sees |
| Output consistency | Structure defined by Meta and scoped by granted permissions | Stable JSON schema across every run |

Use the Graph API when you already manage or have permissioned access to a specific group. Use Facebook Groups Search Scraper when you need to discover groups you don't yet have a relationship with, from a keyword.

### How to use Facebook Groups Search Scraper

Facebook Groups Search Scraper runs as an Apify Actor — no separate signup or API key beyond your Apify account is needed to start a run from the console.

1. Open Facebook Groups Search Scraper on Apify Console.
2. Fill in `startUrls` — the required input — with one or more search keywords (e.g. `"bmw"`) and/or full Facebook group URLs.
3. Optionally set `maxItems` (1–500, default 100) to cap how many groups are collected per keyword.
4. Optionally configure `proxyConfiguration` — leave it empty to use the Actor's automatic default.
5. Click Start and watch the log for discovery and scraping progress.
6. Open the Dataset tab and export results as JSON or CSV, or pull them via the Apify API.

#### How to scale to bulk Facebook group search extraction

`startUrls` accepts an array, so a single run can mix multiple keywords and direct group URLs together — each keyword is processed in turn, up to `maxItems` groups per keyword, while every direct URL is always scraped regardless of that limit. There's no separate bulk-file input; to scale further, add more items to the same array or start additional runs with different keyword batches.

### What can you do with Facebook group data?

- A market researcher scoping a niche uses `memberCountNumeric` and `postsPerDayNumeric` to rank discovered groups by size and activity before deciding where to focus.
- A community manager building an outreach list uses `groupDescription` and `discoverabilityText` to quickly judge each group's focus and whether it's open to new members.
- A growth marketer running keyword sweeps uses `sourceType` and `query` to trace exactly which search term surfaced each group, across a batch run.
- A content planner uses `postsPerMonthNumeric` and `postFrequency` to identify which communities in a category are actively posting versus dormant.
- An AI engineer builds a RAG pipeline that indexes `name` and `groupDescription` into a vector store, letting an agent answer "which groups discuss X" queries with sourced, structured results instead of guessing from memory.

### How does Facebook Groups Search Scraper handle rate limits and blocking?

The Actor runs without a proxy by default. If Facebook or DuckDuckGo returns a blocked response (HTTP 403, 429, 503, or a malformed 202), it automatically upgrades the connection — first to an Apify datacenter proxy, then to a residential proxy — and retries with exponential backoff. Residential-proxy attempts are capped at three retries per request before that request is abandoned. You can also supply your own `proxyConfiguration` to skip straight to a specific proxy setup.

The Actor does not solve CAPTCHAs. If a group's About page still can't be fetched after all retries, that group is simply skipped — a row is only pushed to the dataset once a group name is actually found, so failures never produce a fabricated or half-empty record.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `startUrls` | Yes | array | Add one or more search keywords (e.g. bmw, photography) to find related groups, or paste full Facebook group URLs to scrape them directly. Mix and match — both are supported in one run! | `["bmw", "tesla"]` |
| `maxItems` | No | integer | When you use a keyword, how many groups do you want per search? Choose between 1 and 500. Does not apply to direct group URLs (all of those are scraped). Default: `100` | `50` |
| `proxyConfiguration` | No | object | Optional. Leave default for best compatibility. You can enable proxy here if you prefer; the actor will keep your run going smoothly. | `{"useApifyProxy": false}` |

#### Example input

```json
{
  "startUrls": [
    "bmw",
    "tesla",
    "https://www.facebook.com/groups/1234567890/"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### ⬆️ Output

Every result is a typed, normalized JSON record with a consistent set of fields across every run. Results stream to the Apify dataset live as groups are scraped, and can be exported as JSON or CSV, or read directly via the Apify API.

#### Example output

```json
{
  "query": "bmw",
  "id": "123456789012345",
  "name": "BMW Enthusiasts Worldwide",
  "url": "https://www.facebook.com/groups/bmwenthusiasts/",
  "profilePictureUri": "https://scontent.xx.fbcdn.net/v/t1.6435-9/bmw-cover.jpg",
  "visibility": "Public",
  "memberInfo": "22,345 total members",
  "memberCountNumeric": 22345,
  "postFrequency": "5.2 posts a day",
  "postsPerDayNumeric": 5.2,
  "postsPerMonthNumeric": 156,
  "groupDescription": "A community for BMW owners to share tips, meetups, and marketplace listings.",
  "discoverabilityText": "Anyone can find this group.",
  "type": "Group",
  "viewerJoinState": "CAN_JOIN",
  "sourceType": "keyword",
  "scrapedAt": "2026-07-25T09:04:33.371579+00:00"
}
```

### How does it work?

Facebook Groups Search Scraper takes each keyword and searches DuckDuckGo for matching Facebook groups, extracting group URLs from the search results. It then fetches each group's public About page directly over HTTP — no browser, no login session. If a request is blocked, the Actor automatically upgrades its connection from no proxy to a datacenter proxy, and then to residential, retrying with backoff before giving up on that one group. Only data visible to a logged-out visitor is ever collected — no authenticated content, no member lists, no private groups. The output schema stays the same field-for-field on every run, so downstream code doesn't need to change if Facebook tweaks its page layout.

### Integrations

Facebook Groups Search Scraper works with the tools you already use — call it directly over HTTP, wire it into an AI agent, or trigger it from a no-code automation tool.

#### Calling Facebook Groups Search Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("facebook-groups-search-scraper").call(
    run_input={
        "startUrls": ["bmw", "tesla"],
        "maxItems": 50,
    }
)

for group in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(group["name"], group.get("memberCountNumeric"))
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### MCP integration for AI agents

This Actor is reachable through Apify's own Actors MCP Server (`https://mcp.apify.com`), which exposes any Actor by its store ID as a callable tool for MCP-compatible clients (Claude Desktop, Cursor, VS Code with GitHub Copilot). Add it with a `tools` query parameter, e.g. `https://mcp.apify.com?tools=<your-username>/facebook-groups-search-scraper`, or install the local stdio server with `npx -y @apify/actors-mcp-server`.

#### No-code tools (n8n, Make)

In n8n, use the official Apify node (or the HTTP Request node) to start a run and read back its dataset, feeding discovered groups into downstream nodes like a CRM or spreadsheet. In Make, the Apify module runs the Actor and returns dataset items as a scenario step, so a fresh batch of matching groups can trigger email, spreadsheet, or CRM modules automatically.

### Is it legal to scrape Facebook groups?

Yes — scraping publicly visible Facebook group data is generally lawful, since Facebook Groups Search Scraper only collects what any logged-out visitor can already see on a group's About page: no member names, no member profiles, no private content. Because the output is group-level metadata (name, visibility, description, activity counts) rather than personal data about identifiable individuals, this falls under general web-scraping and terms-of-service considerations rather than a personal-data regime like GDPR or CCPA. Consult legal counsel if your use case involves bulk storage of personal data or expands to scraping content that includes individual members' information.

### Frequently asked questions

#### What Facebook group fields does Facebook Groups Search Scraper return?

It returns group-level metadata including `name`, `memberCountNumeric`, `postsPerDayNumeric`, `visibility`, and `groupDescription`, plus 12 more fields — see the [full fields table](#what-data-can-i-extract-with-facebook-groups-search-scraper) above.

#### Does Facebook Groups Search Scraper require a Facebook account or login?

No. It reads only public About-page data and never uses a Facebook login, session cookie, or authenticated request.

#### How many groups can I extract in one run?

You can set `maxItems` up to 500 groups per keyword, and combine any number of keywords and direct group URLs in a single run — direct URLs aren't capped by `maxItems`.

#### What happens if a search keyword returns zero results?

The Actor logs a warning for that keyword and moves on to the next one; no row is pushed for a keyword that finds no groups, and the run continues normally for any remaining keywords or direct URLs.

#### Can I scrape multiple Facebook groups at once?

Yes. `startUrls` accepts a mixed array of keywords and direct group URLs, so one run can search several terms and scrape several known groups together.

#### Does Facebook Groups Search Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes. It's reachable through Apify's Actors MCP Server for MCP-compatible clients, and it's callable as a plain HTTP endpoint by any agent framework via the Apify API.

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

Yes. Every row is typed, normalized JSON with consistent field names across runs — no HTML parsing or selectors needed. Pass it straight to an LLM, index it in a vector store, or feed it to an agent tool.

#### What happens when Facebook changes its layout or anti-bot system?

The Actor is maintained, and its output schema is designed to stay stable even as Facebook's page markup changes underneath it.

#### Can I use Facebook Groups Search Scraper without managing proxies or browser infrastructure?

Yes. It runs with no proxy by default and automatically upgrades to a datacenter, then residential, Apify proxy if it gets blocked — you don't have to configure or manage any of that yourself unless you want to.

#### Which Facebook group fields work best for AI training data and RAG indexing?

For RAG, index `name` and `groupDescription` — the highest-information text fields. For structured training data, `memberCountNumeric`, `postsPerDayNumeric`, and `postsPerMonthNumeric` return as consistent typed numbers (or `null`) across every record, rather than free-text.

### Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| Facebook Group Post Scraper | Posts, comments, and engagement data from a known Facebook group URL |
| Facebook Groups Posts & Media Scraper | Posts and media collected across multiple Facebook groups |
| Facebook Group Profile Scraper: Rules & Topics Extractor | Group rules, topics, and profile details for a specific group |
| Facebook Group Lead & Contact Scraper | Leads and contact information surfaced within Facebook groups |
| Facebook Marketplace Scraper | Marketplace listing titles, prices, locations, photos, and seller info |
| Facebook Posts Scraper | Facebook Page posts, timestamps, and reaction/engagement breakdowns |

### Your feedback

Found a bug or missing a field? Let us know through the Issues tab on this Actor's Apify Console page, or via Apify's support channel — we actively maintain this Actor and use that feedback to prioritize fixes.

# Actor input Schema

## `startUrls` (type: `array`):

✨ Add one or more search keywords (e.g. bmw, photography) to find related groups, or paste full Facebook group URLs to scrape them directly. Mix and match — both are supported in one run!

## `maxItems` (type: `integer`):

🎯 When you use a keyword, how many groups do you want per search? Choose between 1 and 500. Does not apply to direct group URLs (all of those are scraped).

## `proxyConfiguration` (type: `object`):

⚙️ Optional. Leave default for best compatibility. You can enable proxy here if you prefer; the actor will keep your run going smoothly.

## Actor input object example

```json
{
  "startUrls": [
    "bmw",
    "tesla"
  ],
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

One row per Facebook group, including the matched query, member/post stats, and visibility info.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "bmw",
        "tesla"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/facebook-groups-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [
        "bmw",
        "tesla",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/facebook-groups-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "bmw",
    "tesla"
  ]
}' |
apify call scraper-engine/facebook-groups-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/facebook-groups-search-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/KIfpJkST5OAX2A4EL/builds/ykwCxrqZxdYewwZiH/openapi.json