# Facebook Groups Search Scraper - Members, Activity & Rules (`topapi/facebook-groups-search-scraper`) Actor

Find Facebook groups by keyword and city: group ID, name, URL, cover, exact member count, public or private, posts per day and month, created date, rules and admins. No login, no cookies. $0.80 per 1,000 groups, $2.60 with the About data.

- **URL**: https://apify.com/topapi/facebook-groups-search-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** Social media, Lead generation
- **Features:** Limited permissions
- **Stats:** 11 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 groups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Facebook Groups Search Scraper do?

**Facebook Groups Search Scraper** finds Facebook groups by keyword (with a city or country added to the words) and returns one row per group: numeric group ID, name, URL, cover image, public or private, and, from each group's own About data, the exact member count, visibility, posts in the last day and month, posts per day, new members this week, created date, rename date, description, tags, the group's own locations, the admins and moderators Facebook shows publicly, the rules, and any email or website the group published. It also reads groups you already have from their links, IDs or vanity names.

Facebook group finder · Facebook groups by keyword · Facebook group member count

- **Exact numbers from the group itself:** `memberCount` 79,692, not "79K"; posts in the last day and month from Facebook's own counters
- **Every group's About data in the same row:** privacy, visibility, created date, rename date, tags, locations, rules, admin and moderator names and counts
- **Public and private groups:** Facebook shows a private group's About data to anyone; only its posts are hidden
- **Filters before the charge:** privacy, member range, posts per day or month, location, created date, keyword must appear
- **Monitor mode:** schedule the same search and get only the groups that are new (or whose member count, privacy, name or activity changed) since the last run, with `memberGrowth`
- **No login, cookies or Facebook API key:** plain HTTP, no browser
- **Pay only for delivered rows:** no start fee; a filtered-out, unavailable or already-delivered group is never charged
- **Export anywhere:** JSON, CSV, Excel, XML; schedules, webhooks, Make, Zapier, n8n, Google Sheets; the Apify API and MCP server for AI agents

### What data can you get from Facebook groups?

<table>
<tr><td>🆔 Group ID (numeric), vanity name</td><td>📛 Group name</td><td>🔗 Group URL</td></tr>
<tr><td>👥 Exact members + "4.3K" text</td><td>🔒 Public / private + Facebook's privacy line</td><td>👁️ Visible / hidden + Facebook's line</td></tr>
<tr><td>📈 Posts in the last day and month, posts per day</td><td>🆕 New members in the last week</td><td>📅 Created date, rename date, history line</td></tr>
<tr><td>📝 Full description</td><td>🏷️ Tags</td><td>📍 Group locations</td></tr>
<tr><td>🛡️ Admins and moderators shown publicly (names, counts, line)</td><td>📜 Rules (title + text)</td><td>❓ Membership questions (optional)</td></tr>
<tr><td>📧 Emails and 🌐 websites in the description</td><td>🖼️ Cover image</td><td>🔎 Search term, location, rank, the engine's title and snippet</td></tr>
</table>

Measured over 197 groups read with their About data (2026-10-28, US and UK searches): ID, name, URL, privacy, visibility, member count, posts per day and month, new members, created date and history 100%; cover 96%; description 93%; locations 68%; admins shown by name 64%; rules 64%; a rename date 31%; tags 19%; moderators shown by name 17%; a website in the description 10%; an email 4%. Rows without the About data (397 measured) carry ID, name, URL, privacy and the search snippet 100%, cover 96%. Empty means the group shows nothing there.

### How to scrape Facebook groups with Facebook Groups Search Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up): $5 of monthly credit, no card needed.
2. Open [Facebook Groups Search Scraper](https://apify.com/topapi/facebook-groups-search-scraper) and click **Try for free**.
3. Type your **Search terms** (one per line, e.g. `real estate investors`) and, optionally, a **Location** (`Texas`).
4. Set **Maximum groups in total** and leave **Group About data** on for members, activity, rules and admins.
5. Click **Start**. Rows stream into the dataset as groups are read.
6. Open the **Storage** tab and **Export** as JSON, CSV or Excel, or let a schedule run it for you.

### ⬇️ Input

| Field | What it does | Default |
|---|---|---|
| `searchQueries` (Search terms) | Topics to find groups for, one per line. Also accepted: `keywords`, `queries`, `searchQuery`, `searchTerms`. | sample "dog training" |
| `locations` | City, region or country added to each term ("yoga Austin"); each term runs once per location. Also `searchLocations`. | none |
| `groupUrls` | Groups you already have: links (any facebook.com host, post links too), numeric IDs or vanity names. Also `startUrls`. | none |
| `privacy` | `any`, `public` or `private`. | `any` |
| `minMembers`, `maxMembers` | Member range (exact count). | off |
| `minPostsPerDay`, `minPostsPerMonth` | Keep only active groups. | off |
| `locationContains` | Keep only groups whose locations, name or description mention one of these words. | off |
| `requireKeywordMatch` | Keep only groups whose name or search result contains every word of the term, in any form ("photography" finds "photographers"). | on |
| `createdAfter`, `createdBefore` | Keep only groups created in this window (YYYY-MM-DD). | off |
| `excludeGroupIds` | Groups never to deliver. | none |
| `includeDetails` | Read each group's About data (charged as `group-details`). Off = the search row only. | on |
| `includeRules` | With the About data, include the rules. | on |
| `includeMembershipQuestions` | With the About data, also read whether joining members are asked questions and the visitor join state (one more read per group). | off |
| `requireDetails` | Deliver only rows that carry the About data, and stop when Facebook stops serving it to the run. | off |
| `monitorMode`, `monitorChanges`, `monitorStoreName` | Deliver only new (and, optionally, changed) groups since the last run. | off |
| `monitorRefreshDays` | With changed groups on: re-read a known group's members and activity when its last read is this many days old (0 = only when its name, privacy or cover changed). | 7 |
| `maxItems` | Stop after this many groups in the whole run (0 = no limit). Also `maxResults`, `resultsLimit`. | 100 |
| `maxGroupsPerQuery` | Stop each term x location after this many groups. Also `maxResultsPerQuery`, `maxGroups`. | none |
| `searchEngines` | `yahoo` (default) and/or `duckduckgo`. DuckDuckGo stands in on its own when Yahoo refuses a run. | `yahoo` |
| `maxConcurrency` | Groups read at the same time. | 4 |
| `proxyConfiguration` | Your own proxy replaces the built-in IP ladder for every request. | Apify Proxy |

Every member, activity, location and date filter reads the About data, so it turns `includeDetails` on. The privacy and keyword filters work without it. A filtered-out group is not charged.

#### Example input

```json
{
    "searchQueries": ["real estate investors", "wholesaling"],
    "locations": ["Texas"],
    "maxItems": 200,
    "minMembers": 1000,
    "minPostsPerDay": 1
}
```

### ⬆️ Output

One item per group. A real row from a run on 2026-10-28 (picture links shortened; `admins`, `adminsText`, the alias columns and the empty fields left out here):

```json
{
    "groupId": "437863180271381",
    "groupName": "London Photography Meet-up - Meet, Shoot, Share",
    "groupUrl": "https://www.facebook.com/groups/LondonPhotogs/",
    "vanity": "LondonPhotogs",
    "coverPhotoUrl": "https://scontent-iad6-1.xx.fbcdn.net/v/t39.30808-6/347239247...jpg",
    "privacy": "PUBLIC",
    "privacySource": "about",
    "privacyLabel": "Public",
    "privacyDescription": "Anyone can see who's in the group and what they post.",
    "visibility": "Visible",
    "visibilityDescription": "Anyone can find this group.",
    "memberCount": 4267,
    "memberCountText": "4.3K",
    "membersText": "4,267 total members",
    "postsToday": 0,
    "postsLastMonth": 2,
    "postsPerDay": 0.1,
    "postFrequencyText": "0.1 posts a day",
    "newMembersText": "No new members in the last week",
    "newMemberCount": 0,
    "description": "Welcome to the London Photography Meet-up - Meet, Shoot, Share group! 📸🌆\n\nOur group is all about organizing face-to-face meet-ups where we can come together to indulge in our shared passion for photography...",
    "createdAt": "2019-07-21T17:34:44.000Z",
    "creationDate": "2019-07-21",
    "historyText": "Group created on July 21, 2019. Name last changed on June 27, 2021.",
    "nameLastChanged": "2021-06-27",
    "groupLocations": [{ "id": "106078429431815", "name": "London, United Kingdom" }],
    "location": "London, United Kingdom",
    "adminCount": 4,
    "moderatorCount": 0,
    "adminAndModeratorCount": 4,
    "rules": [
        { "title": "Friendly Environment", "description": "Let's >Foster a community of respect. We're all about encouraging constructive criticism and mutual support..." },
        { "title": "No hate speech or bullying", "description": "Operate with kindness and understanding. Any form of hate speech or bullying won't be tolerated..." }
    ],
    "rulesCount": 5,
    "query": "photography",
    "searchLocation": "London",
    "rank": 2,
    "sourceType": "search",
    "sourceSearchEngine": "yahoo",
    "sourceResultUrl": "https://www.facebook.com/groups/LondonPhotogs/",
    "sourceResultKind": "group",
    "sourceTitle": "London Photography Meet-up - Meet, Shoot, Share | Facebook",
    "detailsIncluded": true,
    "scrapedAt": "2026-10-28T16:16:54.772Z"
}
```

`admins` and `moderators` hold `{name, id, type, url}` for each one Facebook shows a visitor (up to about six). The dataset's **Groups** view shows the main columns. Each run writes a `RUN_SUMMARY` record: per search, the result pages read, groups listed and delivered and why it stopped; the filters; the IPs used and the charges.

### How much does it cost to scrape Facebook groups?

Pay per event, no start fee, no monthly rent:

| Event | Price | When |
|---|---|---|
| `group` | **$0.0008** ($0.80 per 1,000) | every group row delivered |
| `group-details` | **$0.0018** ($1.80 per 1,000) | a row that carries the group's About data |

A row with the About data is **$2.60 per 1,000**; search rows only, $0.80 per 1,000. Measured on 2026-10-28: 10 groups for "yoga Austin" with the About data took 23 s ($0.026); 100 search rows for "vegan recipes" took 85 s ($0.08). Set **Maximum cost per run** in the Console (or `maxTotalChargeUsd` in the API) and the run stops there: a 0.006 USD limit delivered exactly 2 rows with their About data.

### How many groups does one run return?

- **Groups come from a web index.** Facebook's own group search is for signed-in members only (it lists nothing to a signed-out visitor), so groups are found where Facebook publishes them to the open web, then each one is read from Facebook itself. Measured: Yahoo listed 275 different groups over 40 result pages for "yoga austin", and about 85 result pages (~550 results) per run before Yahoo starts answering errors; DuckDuckGo then stands in for a few pages. More terms or locations give more groups; another run later continues.
- **About data per run.** Facebook serves a group's About data to a signed-out visitor about 20 times a minute per IP, and fewer times to an IP it has already seen a lot of. The run reads 6 groups at once and then one every 3 seconds on one IP, so 100 groups with the About data take about 5 minutes. Measured on 2026-10-28 over 10 runs: one run's IP served the About data for 7 to 100 groups (median about 12) before Facebook refused it. Groups found after that are delivered as search rows (charged `group` only, `detailsError` says why), or, with `requireDetails` on, the run stops there. Run again later for the rest.

### Run it on a schedule

Turn on **Monitor mode**, keep the same search terms and add a schedule in the Console (Schedules → Create, e.g. every Monday 09:00). Each run delivers, and charges, only groups no earlier run delivered (remembered in the named key-value store `monitorStoreName`); known groups are skipped before their About data is read. With **Also changed groups**, each known group is first checked for free against Facebook's own record of it (name, public / private, cover). Only a group whose name, privacy or cover changed, or whose last About read is `monitorRefreshDays` old (default 7), is read again; that row is delivered and charged either way, with `monitorStatus: "changed"` (`changed: true`, `previousMemberCount`, `memberGrowth`, `changes`) or `"refreshed"` (`changed: false`, the latest numbers). Measured: a daily poll of a 5-group watch list where nothing changed read no About data and cost $0.00014 (Apify's run start); the weekly re-read of the same 5 groups delivered 2 changed and 3 refreshed rows ($0.013).

API call (Node.js):

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('topapi/facebook-groups-search-scraper').call({
    searchQueries: ['home bakers'],
    locations: ['Chicago'],
    maxItems: 100,
    monitorMode: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### Use cases

- **Community outreach:** every active group for a niche and city, with size, activity and the admins shown publicly
- **Where to post:** rules and membership questions before you join
- **Market sizing:** how many groups, how many members, how active, per topic and place
- **Competitor and brand communities:** track member growth week by week in monitor mode
- **New-group alerts:** monitor mode + `createdAfter`

### FAQ

**Do I need a Facebook account or cookies?** No. The actor reads what Facebook shows a signed-out visitor.

**Why a web index and not Facebook's search?** Facebook's own group search answers 0 groups to a signed-out visitor, so the groups are found where Facebook publishes them to the open web, then each one is read from Facebook itself.

**Are private groups included?** Yes. A private group's About data (members, activity, rules, admins) is public; its posts are not. Measured: 70 of 197 groups read were private.

**Is `memberCount` exact?** Yes, from the group's own activity card ("4,267 total members"); `memberCountText` is the rounded header ("4.3K").

**Who are the admins in `admins`?** The admins and moderators Facebook shows any visitor on the group's About page (up to about six), plus the full counts (`adminCount`, `moderatorCount`).

**Why are some rows without the About data?** Facebook stopped serving it to the run's IP (see "How many groups does one run return?"). Those rows are charged $0.0008, not $0.0026, and `detailsError` says why. Turn on `requireDetails` to stop instead.

**Where does `privacy` come from on a row without the About data?** From where Facebook sends a signed-out visitor: to the posts for a public group, to the About page for a private one (`privacySource: "route"`). It matched the About data on 19 of 19 groups checked.

**Why no posts per week?** Facebook prints only posts in the last day and in the last month to a signed-out visitor.

### Other Facebook scrapers

- [Facebook Pages Search Scraper](https://apify.com/topapi/facebook-pages-search-scraper): Facebook Pages by keyword with contacts
- [Facebook Search Posts Scraper](https://apify.com/topapi/facebook-search-posts-scraper): public posts by keyword
- [Facebook URL to ID](https://apify.com/topapi/facebook-url-to-id): IDs of Pages, profiles, groups and posts
- [Facebook Events Scraper](https://apify.com/topapi/facebook-events-scraper): events by keyword, city or Page

# Actor input Schema

## `searchQueries` (type: `array`):

Topics to find groups for, one per line, e.g. "yoga", "real estate investors", "tesla owners". Each term is searched on its own in a web index of facebook.com/groups.

## `locations` (type: `array`):

Optional city, region or country, one per line, e.g. "Austin" or "London". Each term is searched once per location ("yoga Austin"). Empty = no location.

## `groupUrls` (type: `array`):

Groups you already know, one per line: a link (facebook.com/groups/cheapmealideas, /groups/126966114029232/posts/...), a numeric ID or a vanity name. Each becomes one row.

## `privacy` (type: `string`):

Keep public groups, private groups or both. Facebook shows the About data of private groups to anyone, only their posts are hidden.

## `minMembers` (type: `integer`):

Keep only groups with at least this many members (the exact count from the group's About data). Empty = no minimum.

## `maxMembers` (type: `integer`):

Keep only groups with at most this many members, e.g. 5000 for small local groups. Empty = no maximum.

## `minPostsPerDay` (type: `number`):

Keep only active groups: posts in the last month / 30 at least this, e.g. 1. Empty = any activity.

## `minPostsPerMonth` (type: `integer`):

Keep only groups with at least this many posts in the last month. Empty = any.

## `locationContains` (type: `array`):

Keep only groups whose own locations, name or description mention one of these words, e.g. "Texas". Not case sensitive. Empty = anywhere.

## `requireKeywordMatch` (type: `boolean`):

On: keep only groups whose name or search result (title, snippet) contains every word of the term, in any form ("photography" finds "photographers"); others are skipped before their About data is read. Off: every group listed.

## `createdAfter` (type: `string`):

Keep only groups created on or after this day (YYYY-MM-DD), e.g. new groups of this year.

## `createdBefore` (type: `string`):

Keep only groups created on or before this day (YYYY-MM-DD).

## `excludeGroupIds` (type: `array`):

Group IDs, vanity names or links never to return (groups you already have).

## `includeDetails` (type: `boolean`):

On: each group's About data is read: exact members, privacy, visibility, posts in the last day and month, created date, history, description, tags, locations, admins and moderators shown publicly, rules. Charged as group-details. Off: the search row only.

## `includeRules` (type: `boolean`):

With the About data: include each rule's title and text. Included in the group-details price.

## `includeMembershipQuestions` (type: `boolean`):

With the About data: also read whether the group asks joining members questions (hasMembershipQuestions) and the visitor join state. One more read per group; included in the group-details price.

## `requireDetails` (type: `boolean`):

On: a group whose About data Facebook does not serve is skipped, and the run stops once Facebook refuses the About data to the run's IPs. Off: such groups are delivered as search rows (group event only).

## `monitorMode` (type: `boolean`):

Deliver (and charge) only groups no earlier monitor run delivered. Pairs with a daily or weekly schedule.

## `monitorChanges` (type: `boolean`):

In monitor mode, also deliver known groups that changed. Free check first: a known group's About data is read again only if its name, privacy or cover changed, or its last read is older than the re-read interval; each re-read is delivered and charged.

## `monitorRefreshDays` (type: `integer`):

With changed groups on: re-read a known group's member count and activity when its last read is this many days old (charged as a row, changed true or false). 0 = only on a name, privacy or cover change.

## `monitorStoreName` (type: `string`):

Named key-value store that remembers delivered groups. Use one name per watch list.

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

Stop after this many groups across every search. You pay only for groups delivered. 0 = no limit (a topic + city term lists ~275 groups).

## `maxGroupsPerQuery` (type: `integer`):

Stop each search term (x location) after this many groups. Empty = only the total limit applies.

## `searchEngines` (type: `array`):

Web indexes that list the groups. Yahoo is the default; DuckDuckGo lite is used on its own when Yahoo refuses the run, or for every search when listed here.

## `maxConcurrency` (type: `integer`):

How many groups' About data are read in parallel.

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

Leave as is: the run starts on Apify's own connection and climbs to one Apify datacenter and one residential session only when a step is refused. Your own proxy URLs or groups replace that ladder.

## Actor input object example

```json
{
  "searchQueries": [
    "yoga",
    "real estate investors"
  ],
  "locations": [
    "Austin",
    "London"
  ],
  "groupUrls": [
    "https://www.facebook.com/groups/cheapmealideas",
    "874728723021553",
    "dogtraininghelp"
  ],
  "privacy": "any",
  "requireKeywordMatch": true,
  "includeDetails": true,
  "includeRules": true,
  "includeMembershipQuestions": false,
  "requireDetails": false,
  "monitorMode": false,
  "monitorChanges": false,
  "monitorRefreshDays": 7,
  "monitorStoreName": "facebook-groups-search-monitor",
  "maxItems": 10,
  "searchEngines": [
    "yahoo"
  ],
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per Facebook group found by the searches (or given as a link), with its About data when that is on.

## `summary` (type: `string`):

Per-search counts (pages, groups listed and delivered, why each search stopped), filters, the egress used, charges.

# 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 = {
    "searchQueries": [
        "yoga"
    ],
    "locations": [
        "Austin"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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 = {
    "searchQueries": ["yoga"],
    "locations": ["Austin"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/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 '{
  "searchQueries": [
    "yoga"
  ],
  "locations": [
    "Austin"
  ],
  "maxItems": 10
}' |
apify call topapi/facebook-groups-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/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/eYZLM5YeLCkFLCJO2/builds/BdbWvuYOikI5hJ1rI/openapi.json
