# Scrape Facebook Group Posts by Group ID - Cookieless (`patient_discovery/facebook-group-posts`) Actor

Extract Facebook group posts without login or cookies. Get post content, reactions breakdown, comments count, shares, media attachments, and full author profiles in JSON or CSV. Ideal for community monitoring, competitor research, sentiment analysis, and lead generation at scale.

- **URL**: https://apify.com/patient\_discovery/facebook-group-posts.md
- **Developed by:** [Surge Street](https://apify.com/patient_discovery) (community)
- **Categories:** Social media, Developer tools, Other
- **Stats:** 16 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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 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 Group Posts Scraper - No Login Required**
====================================================

**What does this scraper do?**
------------------------------

This actor extracts posts from public Facebook groups using the group ID.

Enter a group ID, run the actor, and receive structured data including post content, engagement metrics, reactions breakdown, media attachments, and author profiles.

No Facebook login, no cookies, no session handling required.

Cookieless architecture ensures stable, risk-free, and scalable automation.

**Why scrape Facebook group posts?**
------------------------------------

Facebook groups contain high-intent conversations, niche discussions, and real audience insights. This helps marketers, analysts, and sales teams to:

* Monitor trending topics across communities  
* Analyze engagement patterns and reaction breakdowns  
* Perform sentiment and conversation analysis  
* Identify recurring customer pain points  
* Track competitor activity inside niche groups  
* Discover warm leads discussing relevant topics  
* Build structured datasets for community intelligence  

Its cookieless design fits scalable data pipelines without needing Facebook accounts.

**How much will scraping cost?**
--------------------------------

The pricing for this actor is **$2.50 per 1,000 scraped results**. Refer to the pricing page.

Because this actor does not require login or session management, it reduces operational complexity and lowers the risk associated with account-based scraping. This predictable architecture keeps your data pipelines highly stable.

**How to use the scraper**
--------------------------

Here is a **step-by-step guide**:

**Step 1: Open the actor:** Go to your Apify Console and open the scraper.

**Step 2: Enter your input parameters:** In the input field, enter the numeric Facebook `groupId`. You can find it in the group URL after `/groups/`.

**Step 3: Configure extraction depth:** Set optional limits such as number of posts or date filters based on your data needs.

**Step 4: Start the run:** Click Start to begin scraping. The actor will extract publicly available posts from the specified group.

**Step 5: Export or integrate:** Once complete, download the dataset in JSON, CSV, or connect it via API to your analytics, CRM, or BI tools.

**Input parameters**
--------------------

Below are the configuration options you can use to control the scraper.

**Input example**

```json
{
  "groupId": "1439220986320043",
  "maxPosts": 500
}
````

| Field | Type | Description |
|-------|------|-------------|
| groupId | String | Numeric Facebook Group ID found in the group URL |
| maxPosts | Number | Maximum number of posts to extract |

## **What data does this scraper extract?**

**Formats**: JSON, CSV, Excel

**Key Data Fields**:

- `post_id` - Unique identifier for each post
- `url` - Direct link to the post
- `message` - Full text content
- `message_rich` - Rich formatted content
- `timestamp` - Unix timestamp of creation
- `comments_count` - Total number of comments
- `reactions_count` - Total reactions
- `reactions` - Breakdown by type (like, love, wow, haha, sad, angry, care)
- `reshare_count` - Number of shares
- `author.id` - Author's Facebook ID
- `author.name` - Author's display name
- `author.url` - Author profile link
- `author.profile_picture_url` - Author profile image
- `image.uri` - Attached image URL if present
- `image.height` / `image.width` - Image dimensions
- `video` - Video attachment data if present
- `external_url` - External links included in the post

All data is returned as structured JSON with null-safe fields for reliable downstream processing.

### Sample Output

```json
{
  "post_id": "4230362860539161",
  "type": "post",
  "url": "https://www.facebook.com/groups/boardgamecommunity/posts/4230362860539161/",
  "message": "Looking for recommendations on strategy games for 2-4 players. Preferably something with medium complexity and under 90 minutes playtime.",
  "message_rich": "Looking for recommendations on strategy games for 2-4 players. Preferably something with medium complexity and under 90 minutes playtime.",
  "timestamp": 1765705599,
  "comments_count": 23,
  "reactions_count": 15,
  "reshare_count": 2,
  "reactions": {
    "angry": 0,
    "care": 1,
    "haha": 0,
    "like": 12,
    "love": 2,
    "sad": 0,
    "wow": 0
  },
  "author": {
    "id": "pfbid0jTpnC5rAwPLzqpn8G2QbJgAi3u7qyXWyWfYuUokDiVukw2r5TtkfXu5QMrGDeA3Ll",
    "name": "Sarah Mitchell",
    "url": "https://www.facebook.com/sarah.mitchell.37",
    "profile_picture_url": "https://scontent.flhe6-1.fna.fbcdn.net/v/t39.30808-1/profile_pic.jpg"
  },
  "author_title": null,
  "image": null,
  "video": null
}
```

All data is delivered in structured JSON format suitable for community monitoring, competitive intelligence, lead generation, and large-scale Facebook group analysis workflows.

## **Key Features:**

- 📈 Extract posts from public Facebook groups
- 📊 Capture reactions breakdown and engagement metrics
- ⚡ Structured JSON output ready for analytics and automation
- 📈 Retrieve full author profile metadata
- 📊 Access media attachments including images and videos
- ⚡ Scalable architecture for high-volume group extraction
- 🔒 Fully cookieless architecture with no login required

## **FAQs**

**Does this scraper require Facebook login?** No. It is fully cookieless and does not require login credentials.

**Can it scrape private groups?** No. Only publicly accessible Facebook groups can be scraped.

**Can I extract thousands of posts?** Yes. Configure the post limit according to your needs or integrate via API for bulk extraction.

**Other Facebook scrapers that you may find useful:**

[Facebook Page Search Scraper](https://apify.com/patient_discovery/facebook-search-pages)

[Facebook Group Posts Scraper](https://apify.com/patient_discovery/facebook-group-posts)

[Facebook Search Events Scraper](https://apify.com/patient_discovery/facebook-search-events)

[Facebook Page Details Scraper](https://apify.com/patient_discovery/facebook-page-details)

[Facebook Marketplace Details Scraper](https://apify.com/patient_discovery/facebook-marketplace-details)

[Facebook Page Reviews Scraper](https://apify.com/patient_discovery/facebook-page-reviews)

[Facebook Page Posts Scraper](https://apify.com/patient_discovery/facebook-page-posts)

[Facebook Search People Scraper](https://apify.com/patient_discovery/facebook-search-people)

# Actor input Schema

## `groupId` (type: `string`):

Group ID

## `maxPages` (type: `integer`):

Maximum number of pages to fetch (pagination handled automatically)

## Actor input object example

```json
{
  "groupId": "new york",
  "maxPages": 1
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("patient_discovery/facebook-group-posts").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("patient_discovery/facebook-group-posts").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 '{}' |
apify call patient_discovery/facebook-group-posts --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Scrape Facebook Group Posts by Group ID - Cookieless",
        "description": "Extract Facebook group posts without login or cookies. Get post content, reactions breakdown, comments count, shares, media attachments, and full author profiles in JSON or CSV. Ideal for community monitoring, competitor research, sentiment analysis, and lead generation at scale.",
        "version": "1.0",
        "x-build-id": "cxM0ZWifPGaxQULAC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/patient_discovery~facebook-group-posts/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-patient_discovery-facebook-group-posts",
                "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/patient_discovery~facebook-group-posts/runs": {
            "post": {
                "operationId": "runs-sync-patient_discovery-facebook-group-posts",
                "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/patient_discovery~facebook-group-posts/run-sync": {
            "post": {
                "operationId": "run-sync-patient_discovery-facebook-group-posts",
                "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": [
                    "groupId"
                ],
                "properties": {
                    "groupId": {
                        "title": "Group ID",
                        "type": "string",
                        "description": "Group ID",
                        "default": "new york"
                    },
                    "maxPages": {
                        "title": "Maximum Pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of pages to fetch (pagination handled automatically)",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
