# Facebook Groups Scraper (`scrapapi/facebook-groups-scraper`) Actor

Facebook Groups Scraperr extracts public posts, comments, reactions, and group metadata from Facebook groups. Export structured JSON for research, analytics, automation, and monitoring. Fast, scalable, and built for reliable Facebook data scraping workflows. 🚀

- **URL**: https://apify.com/scrapapi/facebook-groups-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 8 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$29.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Scraper

Facebook Groups Scraper is a Facebook groups scraping tool that extracts public group posts, comments, reactions, and group metadata into structured JSON. It solves the pain of manually monitoring discussions by acting as a reliable Facebook group posts scraper and Facebook group data extractor for marketers, developers, researchers, and analysts. With flexible sorting, time filters, and resilient fallbacks, it powers scalable monitoring, analytics, and automation across Facebook communities.

### What data / output can you get?

Below are example fields the actor saves to the Apify dataset for each post. Values are real examples from the output structure.

| Data type | Description | Example value |
| --- | --- | --- |
| facebookUrl | Source Facebook group URL | https://www.facebook.com/groups/germtheory.vs.terraintheory |
| url | Direct link to the post | https://www.facebook.com/groups/germtheory.vs.terraintheory/permalink/26139230289060632/ |
| time | ISO 8601 timestamp (UTC) | 2026-02-18T23:15:08.000Z |
| user.id | Author’s Facebook ID | 895345419797571 |
| user.name | Author’s display name | Anonymous participant |
| text | Post content text | Someone here with contamination OCD? It would be really nice... |
| id | Post node ID | UzpfSTg5NTM0NTQxOTc5NzU3MTpWSzoyNjEzOTIzMDI4OTA2MDYzMg== |
| legacyId | Legacy post ID (permalink ID) | 26139230289060632 |
| feedbackId | Feedback object ID | ZmVlZGJhY2s6MjYxMzkyMzAyODkwNjA2MzI= |
| likesCount | Total reactions count | 7 |
| commentsCount | Total comments count | 7 |
| sharesCount | Total shares count | 0 |
| reactionLikeCount | “Like” reactions | 3 |
| reactionLoveCount | “Love” reactions | 0 |
| topReactionsCount | Sum of top reactions | 7 |
| attachments[].image.uri | Attachment image URL (if present) | https://.../image.jpg |
| topComments[].commentUrl | Link to top comment | https://www.facebook.com/.../?comment_id=26139546935695634 |
| facebookId | Group ID | 430027810407566 |
| groupTitle | Group title (if available) | null |
| pageAdLibrary.is_business_page_active | Ad library flag (always false) | false |
| inputUrl | Input URL for traceability | https://www.facebook.com/groups/germtheory.vs.terraintheory |

Notes:
- The actor exports structured JSON to the Apify dataset. You can download the dataset in JSON or process it in your workflows.
- Bonus structures include rich attachments (photos/albums) and topComments with author references and reaction counts.

### Key features

- 🔒 Always-on residential proxy routing
  - The actor enforces Apify Residential Proxy for all requests to maximize reliability and reduce blocks during Facebook groups crawling.
- 🧭 Flexible post sorting
  - Choose your feed ordering via viewOption: CHRONOLOGICAL, RECENT_ACTIVITY, TOP_POSTS, or CHRONOLOGICAL_LISTINGS for targeted exploration of group discussions.
- ⌛ Precision time filtering
  - Filter results with onlyPostsNewerThan using absolute dates (YYYY-MM-DD) or natural language (e.g., “30 days”, “1 year”) to download Facebook group posts within a specific period.
- 🔍 Search within groups (no login)
  - Narrow results with searchGroupKeyword and searchGroupYear. Ideal for quick, letter-based filtering and year scoping in public groups.
- 🧰 Resilient GraphQL fallback
  - Provide fallbackDocId to keep your Facebook groups crawler operational if Facebook updates its frontend and automatic discovery temporarily fails.
- 🧵 Rich engagement capture
  - Outputs include likesCount, commentsCount, sharesCount, reactionLikeCount, reactionLoveCount, topReactionsCount, and topComments for a robust Facebook group comments scraper workflow.
- 📦 Structured dataset export
  - Clean, ready-to-use JSON records with stable identifiers (id, legacyId), author objects, timestamps, and attachments for analytics pipelines.
- 🔁 Built for scale and stability
  - Automatic retries, anti-blocking delays, and pagination cursors ensure consistent collection at scale using a production-ready Facebook group scraper API approach via Apify.

### How to use Facebook Groups Scraper - step by step

1. Sign in to Apify and open the “facebook-groups-scraper” actor.
2. Paste one or more public group URLs into startUrls (string list). Example: https://www.facebook.com/groups/germtheory.vs.terraintheory
3. Set resultsLimit to control how many posts you want per run (default: 20).
4. Choose viewOption to control sorting: CHRONOLOGICAL, RECENT_ACTIVITY, TOP_POSTS, or CHRONOLOGICAL_LISTINGS.
5. (Optional) Use filters:
   - searchGroupKeyword for lightweight text filtering (best with 1–2 letters).
   - searchGroupYear to scope by year (works best when combined with the keyword).
   - onlyPostsNewerThan to restrict by date (absolute or relative).
6. (Optional) Set fallbackDocId if the run reports a missing doc_id after a Facebook change.
7. (Optional) Configure proxyConfiguration if needed. The actor will still route through Apify Residential Proxy automatically.
8. Click “Run”. Monitor logs as the Facebook groups scraping tool fetches and saves posts.
9. Download the dataset once complete (JSON export) or stream it to your automation.

Pro Tip: Combine onlyPostsNewerThan with viewOption=RECENT_ACTIVITY to focus on fresh, high-engagement threads.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research & trend tracking | Monitor public group conversations to identify emerging topics and sentiment using a Facebook group posts scraper. |
| Community analysis | Map engagement patterns with likes, comments, shares, and top comments for deeper community insights. |
| Competitive intelligence | Track public group chatter around products and brands with a Facebook groups crawler for open communities. |
| Content research | Collect examples, questions, and pain points from real users to inform editorial and product roadmaps. |
| Academic & social research | Export structured Facebook group data for time-bound studies using date filters and sorting. |
| Automation pipelines | Trigger workflows when new posts match your filters, leveraging consistent JSON output in your stack. |

### Why choose Facebook Groups Scraper?

A production-focused Facebook group data extractor built for precision, automation, and resilience.

- ✅ Accurate, structured output: Consistent JSON fields with IDs, timestamps, and engagement metrics.
- 🌍 Public-data only: Works on public groups without login; ideal for safe, policy-aware workflows.
- 📈 Scales with retries: Robust retry logic and residential proxy help minimize blocks on large jobs.
- 🧩 Developer-friendly records: Stable identifiers (id, legacyId) and nested structures (attachments, topComments) for downstream joins.
- 🔧 Sorting & filters that matter: viewOption, onlyPostsNewerThan, searchGroupKeyword, and searchGroupYear for focused datasets.
- 🛡️ Resilient by design: fallbackDocId keeps the Facebook group posts scraper running if Facebook updates its UI.
- 🆚 Better than browser extensions: No manual sessions, no unstable DOM automation—server-side reliability for repeatable runs.

Bottom line: a dependable Facebook groups scraping tool for analytics, automation, and reporting.

### Is it legal / ethical to use Facebook Groups Scraper?

Yes—when done responsibly. This actor is designed to extract publicly available data from Facebook groups. It does not access private groups or authenticated data.

Guidelines:
- Scrape only public groups and publicly visible content.
- Review and comply with Facebook’s terms of service and applicable laws (e.g., GDPR/CCPA).
- Use data responsibly for research, analytics, or monitoring—not for spam or abusive practices.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "https://www.facebook.com/groups/germtheory.vs.terraintheory"
  ],
  "resultsLimit": 20,
  "viewOption": "CHRONOLOGICAL",
  "searchGroupKeyword": "",
  "searchGroupYear": "",
  "onlyPostsNewerThan": "",
  "fallbackDocId": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array (stringList) | Yes | — | Add one or more public Facebook group URLs. Only public groups are supported; private groups require authentication. You can scrape multiple groups in one run. |
| resultsLimit | integer | No | 20 | Maximum number of posts to scrape from each group. Recommended to start with 20–50 to test, then scale up. |
| viewOption | string (enum) | No | CHRONOLOGICAL | Post sorting strategy. Options: CHRONOLOGICAL, RECENT\_ACTIVITY, TOP\_POSTS, CHRONOLOGICAL\_LISTINGS. Note: Post limit applies to “New posts” sorting only. |
| searchGroupKeyword | string | No | "" | Search posts by keyword or letter to filter results. Without login, search capabilities are limited. Best used with 1–2 letters plus the year filter. |
| searchGroupYear | string | No | "" | Year filter (e.g., 2024). For best results, combine with Search Keyword. |
| onlyPostsNewerThan | string | No | "" | Time boundary for posts. Accepts absolute (YYYY-MM-DD) or relative (e.g., “2 weeks”, “30 days”, “1 year”) values. |
| fallbackDocId | string | No | "" | Set a known working GraphQL doc\_id when automatic discovery fails (e.g., after a Facebook frontend update). |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Configure proxy settings for secure and reliable scraping. The actor employs residential proxy routing for operations. |

#### Example JSON output

```json
{
  "facebookUrl": "https://www.facebook.com/groups/germtheory.vs.terraintheory",
  "url": "https://www.facebook.com/groups/germtheory.vs.terraintheory/permalink/26139230289060632/",
  "time": "2026-02-18T23:15:08.000Z",
  "user": {
    "id": "895345419797571",
    "name": "Anonymous participant"
  },
  "text": "Someone here with contamination OCD? It would be really nice to talk with someone who knows the feeling. I find the OCD groups very rude and not a bit compassionate.\nIf someone has the same issue: what does it cause to you, does it get better with the NH eating?",
  "topReactionsCount": 7,
  "feedbackId": "ZmVlZGJhY2s6MjYxMzkyMzAyODkwNjA2MzI=",
  "reactionLikeCount": 3,
  "reactionLoveCount": 0,
  "id": "UzpfSTg5NTM0NTQxOTc5NzU3MTpWSzoyNjEzOTIzMDI4OTA2MDYzMg==",
  "legacyId": "26139230289060632",
  "attachments": [],
  "likesCount": 7,
  "sharesCount": 0,
  "commentsCount": 7,
  "topComments": [
    {
      "commentUrl": "https://www.facebook.com/groups/germtheory.vs.terraintheory/permalink/26139230289060632/?comment_id=26139546935695634",
      "id": "Y29tbWVudDoyNjEzOTIzMDI4OTA2MDYzMl8yNjEzOTU0NjkzNTY5NTYzNA==",
      "feedbackId": "ZmVlZGJhY2s6MjYxMzkyMzAyODkwNjA2MzJfMjYxMzk1NDY5MzU2OTU2MzQ=",
      "date": "2026-02-18T23:57:54.000Z",
      "text": "I grew up with it and started seeing a therapist when I was child...",
      "profileUrl": null,
      "profilePicture": "https://scontent.fmlm1-1.fna.fbcdn.net/v/t39.30808-1/297778910_10227860631765240_3586262800094343766_n.jpg?...",
      "profileId": "1353974969",
      "profileName": "Alisa Ulven",
      "likesCount": "5",
      "threadingDepth": 0
    }
  ],
  "facebookId": "430027810407566",
  "groupTitle": null,
  "pageAdLibrary": {
    "is_business_page_active": false,
    "id": "430027810407566"
  },
  "inputUrl": "https://www.facebook.com/groups/germtheory.vs.terraintheory"
}
```

Notes:

- All fields above are pushed directly via Actor.pushData during the run.
- Some fields may be null or empty when not present on the source page (e.g., groupTitle for certain stories).

### FAQ

#### Does this support private groups or require login?

No. The scraper is designed for public Facebook groups only. The input schema explicitly notes that private groups require authentication and are not supported by this actor.

#### Can I control how many posts are scraped?

Yes. Use the resultsLimit parameter to set a maximum number of posts to extract per group. Start small to validate your setup and then scale up.

#### How do I sort posts (e.g., newest, top posts)?

Use the viewOption parameter. Supported values are CHRONOLOGICAL, RECENT\_ACTIVITY, TOP\_POSTS, and CHRONOLOGICAL\_LISTINGS. Note that the post limit applies to “New posts” sorting only.

#### Can I filter by time or year?

Yes. You can use onlyPostsNewerThan for absolute dates (YYYY-MM-DD) or relative periods like “30 days” and combine searchGroupYear with searchGroupKeyword for year-scoped filtering.

#### What happens if Facebook changes its frontend and the scraper can’t find a doc\_id?

Provide a known working fallbackDocId in the input. The actor is built with automatic discovery and will use your fallback when needed to keep the pipeline running.

#### Are comments and reactions included?

Yes. The output includes likesCount, commentsCount, sharesCount, reactionLikeCount, reactionLoveCount, topReactionsCount, plus an array of topComments with IDs, timestamps, and author references.

#### Do I need to configure a proxy?

You can leave proxyConfiguration as-is. The actor automatically uses Apify Residential Proxy under the hood to improve stability and reduce blocking during Facebook groups crawling.

#### Which export formats are supported?

Results are saved to the Apify dataset in structured JSON. You can download the JSON output and integrate it into your analytics or automation workflows.

### Closing CTA / Final thoughts

Facebook Groups Scraper is built to reliably extract structured, public Facebook group posts at scale. With residential proxy routing, robust sorting and time filters, and a fallback GraphQL doc ID, it powers dependable research, monitoring, and analytics.

Whether you work in marketing, data analysis, or research, this Facebook groups crawler helps you collect clean post data, top comments, reactions, and attachments in JSON. Developers can plug the dataset into pipelines and automation with confidence. Start extracting smarter Facebook group insights today.

# Actor input Schema

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

📌 **Add Your Target Groups** 📌

✨ Paste one or more public Facebook group URLs here.

⚠️ **Important:** Only public groups are supported. Private groups require authentication.

💡 **Tip:** You can scrape multiple groups in one run!

## `resultsLimit` (type: `integer`):

🎯 **Control Your Data Volume** 🎯

Set the maximum number of posts to scrape from each group.

💡 **Smart Tip:** Leave empty to scrape ALL available posts (perfect for comprehensive analysis, but may take longer).

⚡ **Recommended:** Start with 20-50 posts to test, then scale up!

## `viewOption` (type: `string`):

🎭 **Choose Your Sorting Style** 🎭

Select how posts should be organized and displayed:

📅 **Chronological** - Time-travel through posts (oldest → newest)

🔥 **Recent Activity** - Catch the hottest, most active discussions

⭐ **Top Posts** - Discover the most popular and engaging content

🛒 **Chronological Listings** - Perfect for Buy/Sell groups

⚠️ **Note:** Post limit applies to 'New posts' sorting only.

## `searchGroupKeyword` (type: `string`):

🎯 **Find Specific Content** 🎯

Search posts by keyword or letter to filter results.

⚠️ **Limitation:** Without login, search capabilities are limited.

💡 **Pro Strategy:**
• Use 1-2 letters + year filter for optimal results
• Combine with year filter below for precision

📝 **Note:** Full words may not return results in most cases.

## `searchGroupYear` (type: `string`):

🗓️ **Time-Travel to Specific Years** 🗓️

Filter posts from a specific year (e.g., 2024, 2023, 2022).

📌 **Important:** Must be used together with the Search Keyword field above for best results.

💡 **Example:** Enter "2024" to get posts from that year only.

## `onlyPostsNewerThan` (type: `string`):

⏰ **Set Your Time Boundary** ⏰

Stop scraping when posts are older than this date.

📝 **Format Options:**
• **Absolute:** YYYY-MM-DD (e.g., 2024-01-15)
• **Relative:** Natural language (e.g., "2 weeks", "7 days", "1 month")

💡 **Examples:**
• "2024-01-01" - Posts from January 2024 onwards
• "30 days" - Posts from the last month
• "1 year" - Posts from the last year

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

🛡️ **Enterprise-Grade Security** 🛡️

Configure proxy settings for secure and reliable scraping.

✨ **Features:**
• ✅ Automatic residential proxy rotation
• 🔄 Smart auto-retry mechanism
• 🚀 Ensures complete data collection
• 🔒 Protects your scraping activities

💡 **Recommended:** Enable for large-scale scraping operations!

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/groups/cheapmealideas/"
  ],
  "resultsLimit": 10,
  "viewOption": "CHRONOLOGICAL",
  "searchGroupKeyword": "",
  "searchGroupYear": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "https://www.facebook.com/groups/cheapmealideas/"
    ],
    "onlyPostsNewerThan": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/facebook-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 = {
    "startUrls": ["https://www.facebook.com/groups/cheapmealideas/"],
    "onlyPostsNewerThan": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/facebook-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 '{
  "startUrls": [
    "https://www.facebook.com/groups/cheapmealideas/"
  ],
  "onlyPostsNewerThan": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/facebook-groups-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Groups Scraper",
        "description": "Facebook Groups Scraperr extracts public posts, comments, reactions, and group metadata from Facebook groups. Export structured JSON for research, analytics, automation, and monitoring. Fast, scalable, and built for reliable Facebook data scraping workflows. 🚀",
        "version": "0.1",
        "x-build-id": "CWqIMfHlxkV0opyhT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~facebook-groups-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-facebook-groups-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapapi~facebook-groups-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-facebook-groups-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapapi~facebook-groups-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-facebook-groups-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Facebook Group URLs",
                        "type": "array",
                        "description": "📌 **Add Your Target Groups** 📌\n\n✨ Paste one or more public Facebook group URLs here.\n\n⚠️ **Important:** Only public groups are supported. Private groups require authentication.\n\n💡 **Tip:** You can scrape multiple groups in one run!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "📊 Number of Posts to Scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🎯 **Control Your Data Volume** 🎯\n\nSet the maximum number of posts to scrape from each group.\n\n💡 **Smart Tip:** Leave empty to scrape ALL available posts (perfect for comprehensive analysis, but may take longer).\n\n⚡ **Recommended:** Start with 20-50 posts to test, then scale up!",
                        "default": 10
                    },
                    "viewOption": {
                        "title": "🔄 Post Sorting Strategy",
                        "enum": [
                            "CHRONOLOGICAL",
                            "RECENT_ACTIVITY",
                            "TOP_POSTS",
                            "CHRONOLOGICAL_LISTINGS"
                        ],
                        "type": "string",
                        "description": "🎭 **Choose Your Sorting Style** 🎭\n\nSelect how posts should be organized and displayed:\n\n📅 **Chronological** - Time-travel through posts (oldest → newest)\n\n🔥 **Recent Activity** - Catch the hottest, most active discussions\n\n⭐ **Top Posts** - Discover the most popular and engaging content\n\n🛒 **Chronological Listings** - Perfect for Buy/Sell groups\n\n⚠️ **Note:** Post limit applies to 'New posts' sorting only.",
                        "default": "CHRONOLOGICAL"
                    },
                    "searchGroupKeyword": {
                        "title": "🔍 Search Keyword Filter",
                        "type": "string",
                        "description": "🎯 **Find Specific Content** 🎯\n\nSearch posts by keyword or letter to filter results.\n\n⚠️ **Limitation:** Without login, search capabilities are limited.\n\n💡 **Pro Strategy:** \n• Use 1-2 letters + year filter for optimal results\n• Combine with year filter below for precision\n\n📝 **Note:** Full words may not return results in most cases.",
                        "default": ""
                    },
                    "searchGroupYear": {
                        "title": "📅 Year Filter",
                        "type": "string",
                        "description": "🗓️ **Time-Travel to Specific Years** 🗓️\n\nFilter posts from a specific year (e.g., 2024, 2023, 2022).\n\n📌 **Important:** Must be used together with the Search Keyword field above for best results.\n\n💡 **Example:** Enter \"2024\" to get posts from that year only.",
                        "default": ""
                    },
                    "onlyPostsNewerThan": {
                        "title": "📅 Posts Newer Than",
                        "pattern": "^$|^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "⏰ **Set Your Time Boundary** ⏰\n\nStop scraping when posts are older than this date.\n\n📝 **Format Options:**\n• **Absolute:** YYYY-MM-DD (e.g., 2024-01-15)\n• **Relative:** Natural language (e.g., \"2 weeks\", \"7 days\", \"1 month\")\n\n💡 **Examples:**\n• \"2024-01-01\" - Posts from January 2024 onwards\n• \"30 days\" - Posts from the last month\n• \"1 year\" - Posts from the last year"
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy & Security Settings",
                        "type": "object",
                        "description": "🛡️ **Enterprise-Grade Security** 🛡️\n\nConfigure proxy settings for secure and reliable scraping.\n\n✨ **Features:**\n• ✅ Automatic residential proxy rotation\n• 🔄 Smart auto-retry mechanism\n• 🚀 Ensures complete data collection\n• 🔒 Protects your scraping activities\n\n💡 **Recommended:** Enable for large-scale scraping operations!"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
