# Facebook Groups Search Scraper (members, privacy, no login) (`datahamster/facebook-groups-search`) Actor

Facebook groups search by keyword: find public groups and get member count, privacy, description, group id, and any website or email the group published in its description. No login, no cookies. Filter by group size, monitor member-count changes, pay only for the group rows you actually get.

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

## Pricing

from $2.40 / 1,000 result items

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Facebook Groups Search Scraper (members, privacy, no login)

Search Facebook groups by keyword and get one flat row per group: member count, privacy, description, group id and the URL — no Facebook account, no cookies, no session.

**Try it:** the prefilled example returns 10 rows in about 35 seconds and costs about $0.032. Results cost $3 per 1,000.

### What you get

Real rows from the example dataset (`queries: ["yoga kyiv"]`, plus one group added via **Group URLs**):

| name | memberCount | privacy | description |
|---|---|---|---|
| Yoga in Ukraine in English - Kyiv, Dnipropetrovsk... | `378` | `public` | "This group is intended for all activities, information and studies on Yoga in Ukraine…" |
| yoga.kyiv | — | `private` | — (login wall: name and URL only, no numbers) |
| Python *(added via Group URLs)* | `149` | `public` | "What is Python…" |

Full row: `id`/`slug`, `url`, `groupId`, `name`, `memberCount`, `memberCountText`, `privacy`, `visibility`, `description`, `website`, `email`, `detailsFetched`, `query`, `rank`, `source`, `scrapedAt`.

### Use cases

- **Community managers** — shortlist public groups to post announcements or promotions in, filtered to a member-size range so tiny dead groups and 500k mega-groups don't waste your time.
- **Market researchers** — size a niche by keyword or city: how many public groups exist, how big they are, what they say about themselves in their own description.
- **Agencies** — build an outreach list of public groups (group names and admin-published contacts, not individual people) for a client's niche, in minutes instead of manual searching.

### Try it in 10 seconds

Hit **Start**/**Try it** — the input already works: `queries: ["yoga kyiv"]`, `resultsPerQuery: 10`, `maxItems: 20`, nothing required. Swap in your own keywords and run again.

To track a niche over time instead of a one-off pull: save the task, set **Mode** to `monitor`, and put it on a schedule (Apify → Schedules → cron `0 8 * * 1` for weekly). Each run then returns only groups that are new or whose member count/privacy changed since last time, and can post the diff to a webhook or Telegram.

**Guide:** [How to find Facebook groups by keyword without login](https://dev.to/dubnytskiy/how-to-find-facebook-groups-by-keyword-without-login-1ge4) walks through a real run, the monitor mode and the FAQ.

### Related actors

- [Facebook Pages Search: Business Contacts, Followers, Monitor](https://apify.com/datahamster/facebook-pages-search) — need the business's public Page instead of its Groups: contacts, followers, monitor mode.
- [Telegram Channel Search Scraper (topic, subscribers, no login)](https://apify.com/datahamster/telegram-channels-search) — the same keyword-and-size discovery, but for Telegram channels.
- [Reddit Scraper (subreddit posts, search, comments, no login)](https://apify.com/datahamster/reddit-scraper) — communities built around subreddits instead of Facebook groups.
- [Facebook Reels Scraper (page reels, views, MP4, no login)](https://apify.com/datahamster/facebook-reels-videos) — once you have the Page, pull its video content and view counts.
- [Threads Scraper — Posts, Profiles, Replies & Search, No Login](https://apify.com/datahamster/threads-scraper) — search Threads instead of Facebook for the same topic.

### How it works

1. **Discovery** — each keyword is searched in a public search-engine index restricted to `facebook.com/groups`, so you get groups Facebook itself has published to the open web. Post links collapse into their group.
2. **Enrichment** (`fetchDetails`) — each group page is opened as a logged-out visitor to read `memberCount`, `privacy`, `description` and `groupId`. Private groups show a login wall and come back as `privacy: private` with no numbers.
3. **Contacts** — `website` and `email` are the first link and the first email address the group published in its own description. No extra requests, no personal data: these are group-level, self-published contacts.

### Input

| Field | Meaning | Default |
|---|---|---|
| `queries` | Keywords to search groups for, e.g. `yoga kyiv` | `["yoga kyiv"]` |
| `groupUrls` | Known group URLs to enrich directly | empty |
| `resultsPerQuery` | Search hits scanned per keyword (1-200) | `10` |
| `fetchDetails` | Open each group page for members/privacy/description | `true` |
| `minMembers` / `maxMembers` | Keep only groups inside that size range | empty (no filter) |
| `maxItems` | Stop after this many group rows | `20` |
| `mode` | `scrape` or `monitor` (only new/changed since last run) | `scrape` |
| `monitorStateId`, `webhookUrl`, `telegramBotToken`, `telegramChatId` | Monitor-mode state key and alert targets | empty |

### Pricing

| Event | Price |
|---|---|
| result | $0.003 per group ($3 per 1,000) |
| monitor-check | $0.006 per monitor run |
| change | $0.003 per new/changed group |

Charged only for groups actually pushed. Residential proxy traffic is billed by Apify on top (group pages hit a login wall from datacenter IPs).

**Found it useful?** A short review on the Store page helps other people find this actor and tells us what to improve. If something is wrong, open an issue on the actor page — issues are answered within a day.

### Why this actor

- No login and no cookies to supply — nothing to keep alive, nothing to get banned.
- Member-size filter built in, so you can ask for "groups between 1,000 and 50,000 members" instead of filtering afterwards.
- Monitor mode with webhook and Telegram alerts on member-count and privacy changes.
- A run that finds nothing pushes nothing, so it charges no result events; the run summary says why it was empty instead of leaving you guessing.

### Limits

- Facebook's own group search needs a login and is not used; discovery depends on the search-engine index, which favours groups with public activity. Very small or freshly created groups may be missing.
- Private groups: name only, no member count.
- No posts, members or admin lists — only group-level facts.

### FAQ

**Does it need a Facebook login or cookies?** No. There is no account field and no cookie input. Everything comes from pages Facebook serves to logged-out visitors, which is also why private groups return a name and nothing else.

**What happens when there are no results?** The dataset is empty and no result events are charged. The `RUN_SUMMARY` record in the run's key-value store carries `emptyReason`, so you can tell "the keyword really has no public groups" from "the search index answered with a challenge".

**Can I get the members or the posts of a group?** No. This actor returns group-level facts only — no member lists, no posts, no comments, no personal data about individuals.

### Changelog

- 0.1: initial release — keyword discovery, group enrichment, monitor mode.
- 0.2: member-size filter, website/email from description; empty search results are retried and reported as a block instead of an empty dataset.
- Yahoo discovery now reads every organic result block; runs return more hits per query.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search public Facebook groups for, one per line, e.g. "yoga kyiv", "expats lisbon", "shopify dropshipping". Each keyword is run against a public search index restricted to facebook.com/groups.

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

Known group pages to enrich directly, full URLs, e.g. "https://www.facebook.com/groups/pythonprogramminglanguage/". Works with the numeric id too: "https://www.facebook.com/groups/692268140863644/". Can be combined with Search queries or used alone.

## `resultsPerQuery` (type: `integer`):

How many search hits to scan per keyword, e.g. 10. More hits mean more groups but a longer run; after de-duplication the number of groups is usually lower. Range 1-200.

## `fetchDetails` (type: `boolean`):

true = open each group page as a logged-out visitor to read memberCount, privacy, description and groupId (one extra request per group). false = return only the URL, slug and name found by search. Example: true.

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

Keep only groups with at least this many members, e.g. 500. Groups whose member count is unknown (private group, or "Open group pages" turned off) are skipped while this filter is set. Leave empty for no lower bound.

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

Keep only groups with at most this many members, e.g. 20000. Groups whose member count is unknown (private group, or "Open group pages" turned off) are skipped while this filter is set. Leave empty for no upper bound.

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

Stop after this many group rows, e.g. 20. You are charged only for rows actually pushed to the dataset.

## `mode` (type: `string`):

"scrape" returns every matching group. "monitor" returns only groups that are new or whose member count / privacy changed since the previous run of the same saved task. Example: "scrape".

## `monitorStateId` (type: `string`):

Optional state id when not running as a saved task (monitor mode)

## `webhookUrl` (type: `string`):

Optional HTTPS URL that receives a POST with a JSON summary of the changes found in monitor mode, e.g. "https://hooks.zapier.com/hooks/catch/123/abc".

## `telegramBotToken` (type: `string`):

Optional Telegram bot token used to send monitor-mode change summaries, e.g. "123456789:AAE...". Leave empty to skip Telegram alerts.

## `telegramChatId` (type: `string`):

Optional Telegram chat id that receives the monitor-mode summaries, e.g. "-1001234567890" for a channel or "123456789" for a direct chat.

## Actor input object example

```json
{
  "queries": [
    "yoga kyiv"
  ],
  "resultsPerQuery": 10,
  "fetchDetails": true,
  "maxItems": 20,
  "mode": "scrape"
}
```

# Actor output Schema

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

All pushed rows (dataset, JSON)

## `resultsTable` (type: `string`):

Dataset in the Console viewer

## `runSummary` (type: `string`):

RUN_SUMMARY record (pushed, skipped, emptyReason)

# 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 = {
    "queries": [
        "yoga kyiv"
    ],
    "resultsPerQuery": 10,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datahamster/facebook-groups-search").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 = {
    "queries": ["yoga kyiv"],
    "resultsPerQuery": 10,
    "maxItems": 20,
}

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

```

## MCP server setup

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

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/51umUnSbrTfEUBMV3/builds/NVBsJYOdvJpUqjg43/openapi.json