# GroupWhat WhatsApp Groups Scraper (`automation-lab/groupwhat-whatsapp-groups-scraper`) Actor

🔎 Search GroupWhat's public WhatsApp directory by keyword, category, country, language, or listing URL. Export structured invite links and metadata.

- **URL**: https://apify.com/automation-lab/groupwhat-whatsapp-groups-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 whatsapp groups

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## GroupWhat WhatsApp Groups Scraper

Find public WhatsApp group listings in GroupWhat and export structured invite-link data in minutes.

Use keywords, GroupWhat directory URLs, categories, countries, or languages.
The Actor returns names, descriptions, invite URLs, tags, taxonomy, timestamps, and source provenance.
It does not join groups, read messages, or require a WhatsApp account.

### What does GroupWhat WhatsApp Groups Scraper do?

GroupWhat WhatsApp Groups Scraper reads the public directory at [GroupWhat](https://groupwhat.com/).
It turns directory listings into clean JSON, CSV, Excel, XML, or RSS-ready records in an Apify Dataset.

You can:

- 🔎 Search public group listings by keyword.
- 🗂️ Crawl a GroupWhat category URL.
- 🌍 Filter groups by country.
- 🗣️ Filter groups by language.
- 🔗 Look up one exact GroupWhat group page.
- 📊 Export invite links with descriptions and tags.
- 🔄 Schedule repeat runs to detect newly listed communities.

### Who is it for?

#### Community researchers

Map public communities around an industry, location, language, or interest.
Keep the GroupWhat listing URL so every record has clear provenance.

#### Growth and partnership teams

Find public communities relevant to a campaign or partnership hypothesis.
Review each community before outreach and follow its published rules.

#### Market intelligence teams

Compare community activity across categories, countries, and languages.
Use listing update times and view counts as directory-level signals.

#### Developers and data teams

Feed normalized public invite-link records into a database, dashboard, or enrichment pipeline.
Run the Actor through the API, webhook integrations, schedules, or MCP.

### Why use this Actor?

GroupWhat exposes useful public information, but copying listings manually does not scale.
This Actor provides a repeatable data contract.

- ✅ No WhatsApp login required.
- ✅ No browser or residential proxy required for the current public data route.
- ✅ Strict URL validation prevents accidental crawling outside GroupWhat.
- ✅ Unknown category, country, and language filters fail clearly.
- ✅ Duplicate listings across queries are removed by stable GroupWhat ID.
- ✅ Per-record charging means output volume is predictable.
- ✅ Source and scrape timestamps support monitoring workflows.

### What data can you extract?

| Field | Description |
|---|---|
| `listingId` | Stable GroupWhat listing ID |
| `name` | Public group name |
| `description` | Public directory description |
| `inviteUrl` | Public `chat.whatsapp.com` invite URL |
| `inviteCode` | Invite code parsed from the URL |
| `listingUrl` | Exact GroupWhat detail page |
| `category` | GroupWhat category name |
| `categorySlug` | Category URL slug |
| `country` | GroupWhat country name |
| `countrySlug` | Country URL slug |
| `language` | GroupWhat language name |
| `languageSlug` | Language URL slug |
| `tags` | Public listing tags |
| `imageUrl` | Public image URL, when requested and available |
| `views` | GroupWhat directory view count, when available |
| `memberCount` | Public member count, when available |
| `createdAt` | Listing creation timestamp |
| `updatedAt` | Listing update timestamp |
| `sourceUrl` | URL or API route used to find the record |
| `searchQuery` | Keyword that found the record, when applicable |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape public GroupWhat WhatsApp groups

1. Open the Actor input page.
2. Add one or more `searchQueries`, such as `business` or `travel`.
3. Optionally add GroupWhat category, country, language, or detail URLs.
4. Add taxonomy filters if you need a narrower dataset.
5. Keep `maxItems` low for your first run.
6. Choose whether to include image URLs.
7. Click **Start**.
8. Open the Dataset tab to inspect or export records.

A small first run usually finishes quickly because extraction uses public HTTP endpoints rather than a browser.

### Input options

#### Search queries

`searchQueries` accepts a list of phrases.
GroupWhat searches names, descriptions, and tags on its public directory.
Different phrases may return the same listing; the Actor deduplicates it.

#### Start URLs

`startUrls` accepts only these public GroupWhat routes:

- `https://groupwhat.com/`
- `https://groupwhat.com/groups/<slug>`
- `https://groupwhat.com/category/<slug>`
- `https://groupwhat.com/country/<slug>`
- `https://groupwhat.com/language/<slug>`

Other domains and unsupported paths fail with a clear validation error.

#### Directory filters

`categories`, `countries`, and `languages` accept either names or slugs.
Examples include `Business`, `technology`, `India`, `south-africa`, `English`, and `Persian`.
Filters are resolved against GroupWhat's live public taxonomy.
A misspelled or unknown value fails closed instead of returning unrelated records.

#### Output controls

`maxItems` accepts 1 to 5,000 unique records.
`includeImages` controls whether public image URLs are included.
Disabling images shortens records but does not download the image content either way.

### Example inputs

#### Keyword search

```json
{
  "searchQueries": ["business", "entrepreneurship"],
  "maxItems": 50,
  "includeImages": true
}
```

#### Category URL

```json
{
  "startUrls": [
    { "url": "https://groupwhat.com/category/technology" }
  ],
  "maxItems": 100
}
```

#### Country and language monitor

```json
{
  "countries": ["India"],
  "languages": ["English"],
  "maxItems": 250,
  "includeImages": false
}
```

#### Exact listing lookup

```json
{
  "startUrls": [
    { "url": "https://groupwhat.com/groups/H_KbbUUumm4jpNsiD9_uy" }
  ],
  "maxItems": 1
}
```

### Example output

```json
{
  "listingId": 5433,
  "name": "Ahmedabad Home Ride Wash",
  "description": "Ahmedabad Home ride wash facility available for all the Ahmedabad citizens",
  "inviteUrl": "https://chat.whatsapp.com/LjRAqSHTGIRGCel3iWtdcZ",
  "inviteCode": "LjRAqSHTGIRGCel3iWtdcZ",
  "listingUrl": "https://groupwhat.com/groups/H_KbbUUumm4jpNsiD9_uy",
  "category": "Business",
  "categorySlug": "business",
  "country": "India",
  "countrySlug": "india",
  "language": "English",
  "languageSlug": "english",
  "tags": ["Ahmedabad Home Ride Wash"],
  "views": 2,
  "sourceUrl": "https://groupwhat.com/groups/H_KbbUUumm4jpNsiD9_uy",
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

Values change as GroupWhat updates its directory.
Optional fields are omitted when the source does not provide them.

### How much does it cost to scrape GroupWhat WhatsApp groups?

This Actor uses pay-per-event pricing.
A small one-time start event covers run initialization.
A result event is charged for each unique WhatsApp group saved to the Dataset.

Current prices are:

| Apify plan tier | Price per saved group |
|---|---:|
| FREE | $0.000049433 |
| BRONZE | $0.000042985 |
| SILVER | $0.000033528 |
| GOLD | $0.000025791 |
| PLATINUM | $0.000017194 |
| DIAMOND | $0.000012036 |

The Actor start event is **$0.005** per run.
A representative 67-record technology-category run cost about $0.0083 at the FREE event rates, including the start event.
Always check the live Actor pricing panel for authoritative prices.
You are not charged a result event for filtered-out duplicates.
Set `maxItems` to cap output and cost.

### Search, filtering, and deduplication

Keyword results can overlap.
A group may also appear in both a search query and a category crawl.
The Actor uses the stable GroupWhat listing ID to emit each group once per run.

Filters combine as intersections:

- Multiple categories represent allowed categories.
- Multiple countries represent allowed countries.
- Multiple languages represent allowed languages.
- Country and language together require both to match.

This makes targeted monitoring repeatable and prevents silent broadening.

### Monitoring newly listed WhatsApp groups

Create an Apify schedule to run the same input hourly, daily, or weekly.
Send the resulting Dataset to a webhook or automation platform.
Compare `listingId` or `inviteCode` against records from the previous run.
Use `createdAt`, `updatedAt`, and `scrapedAt` to distinguish source changes from collection time.

A practical workflow:

1. Run one category-and-country input daily.
2. Store stable IDs in your database.
3. Insert IDs you have not seen before.
4. Flag changed `updatedAt` timestamps for review.
5. Verify an invite remains relevant before contacting or joining a community.

### Integrations

#### Google Sheets

Export the Dataset as CSV or connect Apify to a Sheets workflow.
Use one row per public group and deduplicate on `listingId`.

#### Zapier or Make

Trigger a scenario when a scheduled run finishes.
Filter for new IDs, then send records to a CRM, Slack channel, or review queue.

#### Webhooks

Attach a run-succeeded webhook and fetch Dataset items through the API.
This works well for recurring community-monitoring pipelines.

#### Databases and BI tools

Load JSON or CSV into PostgreSQL, BigQuery, Snowflake, Airtable, or a dashboard.
Keep source URLs for auditability.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/groupwhat-whatsapp-groups-scraper').call({
  searchQueries: ['real estate'],
  countries: ['India'],
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/groupwhat-whatsapp-groups-scraper").call(run_input={
    "searchQueries": ["travel"],
    "languages": ["English"],
    "maxItems": 50,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~groupwhat-whatsapp-groups-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["Business"],"maxItems":25}'
```

After the run succeeds, fetch items from its default Dataset endpoint.
Never expose an Apify token in client-side code or a public repository.

### Use with Apify MCP

#### Claude Code

Connect this Actor with the exact HTTP transport command:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com/?tools=automation-lab/groupwhat-whatsapp-groups-scraper"
```

#### Claude Desktop and Cursor

Add this server to the `mcpServers` object in Claude Desktop or Cursor:

```json
{
  "mcpServers": {
    "apify-groupwhat": {
      "url": "https://mcp.apify.com/?tools=automation-lab/groupwhat-whatsapp-groups-scraper"
    }
  }
}
```

#### VS Code

Use the same MCP server URL in your VS Code MCP configuration and authenticate with your Apify account when prompted.

Example prompts:

- “Find 25 public business WhatsApp groups listed in GroupWhat.”
- “Export English-language GroupWhat communities in India as JSON.”
- “Look up this GroupWhat listing URL and return its public invite metadata.”
- “Run my saved community monitor and summarize newly seen listing IDs.”

### Tips for reliable results

- Start with 10 to 25 records while refining filters.
- Use exact GroupWhat taxonomy names or slugs.
- Prefer a detail URL when you already know the listing.
- Combine a country and language for focused regional research.
- Use stable `listingId` values for cross-run deduplication.
- Treat view and member counts as optional source-provided signals.
- Verify public invite links before any outreach workflow.
- Schedule at a respectful frequency; directory content does not require minute-level polling.

### Limitations

GroupWhat is a third-party directory and can change its pages, taxonomy, or public endpoints.
Listings may be removed, renamed, or updated after extraction.
WhatsApp invite links may expire or be revoked by group administrators.
The Actor reports public directory data; it does not guarantee that an invite is still active.

Search relevance is determined by GroupWhat's public search service.
A query can return fewer records than `maxItems`.
Some groups have no public member count or image.
The Actor does not discover private or unlisted groups.

### Responsible use and legality

Only public GroupWhat listing metadata is collected.
The Actor does not log in to WhatsApp, join groups, enumerate participants, or read messages.

You are responsible for your use of the data.
Respect GroupWhat's terms, WhatsApp's terms, community rules, privacy rights, anti-spam laws, and applicable data-protection laws.
Do not use invite links for harassment, unsolicited bulk messaging, or attempts to access restricted communities.
Review each community's context before outreach.

### Troubleshooting

#### “Unknown category/country/language filter”

Check the spelling or use the slug visible in the corresponding GroupWhat URL.
The Actor intentionally fails closed so a typo does not produce a broad unrelated dataset.

#### “Unsupported start URL”

Use only `groupwhat.com` homepage, detail, category, country, or language URLs.
Remove tracking redirects or unrelated WhatsApp URLs from `startUrls`.

#### The Dataset is empty

The query and filter intersection may have no public matches.
Try one broader query or remove one filter.
A valid zero-match query is not a technical failure.

#### An invite does not open

Administrators can revoke WhatsApp invite codes after GroupWhat indexed them.
Use `listingUrl` and `updatedAt` to review the source, then rerun later.

### Related scrapers

Choose [Google Search Results Scraper](https://apify.com/automation-lab/google-search-scraper) when you need broad web discovery beyond GroupWhat.
Choose [Website Content Crawler](https://apify.com/automation-lab/website-content-crawler) when your goal is general website text extraction rather than structured WhatsApp group records.

This Actor is the focused option when GroupWhat taxonomy, listing provenance, and public invite metadata are central to the workflow.

### FAQ

#### Does this Actor join WhatsApp groups?

No.
It only reads public listing data and public invite URLs already published by GroupWhat.

#### Does it read messages or member phone numbers?

No.
Messages, member lists, and private WhatsApp data are outside the product scope.

#### Do I need a WhatsApp account?

No.
The current extraction route is anonymous HTTP and does not use WhatsApp Web.

#### Can I search by country and language together?

Yes.
The filters are combined, so each emitted result must match both.

#### Can I scrape one exact listing?

Yes.
Pass its `https://groupwhat.com/groups/<slug>` URL in `startUrls`.

#### Why did I receive fewer results than `maxItems`?

`maxItems` is a ceiling, not a promised count.
The source may contain fewer matches for your query and filter combination.

#### Can I monitor changes?

Yes.
Schedule repeat runs and compare stable `listingId`, `inviteCode`, and `updatedAt` values.

#### Are image files downloaded?

No.
When enabled, `imageUrl` stores the public source URL only.

#### Can I use the output commercially?

That depends on your jurisdiction, purpose, and the relevant platform and community terms.
Consult qualified legal advice for your use case.

# Actor input Schema

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

Keywords to search in public GroupWhat group names, descriptions, and tags.

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

Group detail, category, country, language, or homepage URLs on groupwhat.com.

## `categories` (type: `array`):

GroupWhat category names or slugs, such as Business or technology.

## `countries` (type: `array`):

GroupWhat country names or slugs, such as India, Global, or south-africa.

## `languages` (type: `array`):

GroupWhat language names or slugs, such as English or Persian.

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

Stop after saving this many unique public WhatsApp group listings.

## `includeImages` (type: `boolean`):

Include public group image URLs when GroupWhat provides them.

## Actor input object example

```json
{
  "searchQueries": [
    "business"
  ],
  "startUrls": [
    {
      "url": "https://groupwhat.com/category/business"
    }
  ],
  "maxItems": 10,
  "includeImages": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        "business"
    ],
    "startUrls": [
        {
            "url": "https://groupwhat.com/category/business"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/groupwhat-whatsapp-groups-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": ["business"],
    "startUrls": [{ "url": "https://groupwhat.com/category/business" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/groupwhat-whatsapp-groups-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "business"
  ],
  "startUrls": [
    {
      "url": "https://groupwhat.com/category/business"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/groupwhat-whatsapp-groups-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/groupwhat-whatsapp-groups-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ty7KpsOf7xo6ZT4er/builds/eEoHkEjaceANRxlyt/openapi.json