How to Monitor a Facebook Group's New Posts Automatically (After the Groups API Shutdown)

To monitor a public Facebook group's new posts automatically, call a Facebook data API on a schedule (every hour is plenty for most groups), keep the IDs of posts you've already seen, and send each new post to Slack, email or a spreadsheet. Meta's own Groups API can't do this anymore: Meta removed it on April 22, 2024, so the integrations that depended on it stopped working. Below is a working version in about 40 lines of Python, and the same thing as a no-code n8n workflow.

Why the usual answers don't work anymore

Most guides you'll find were written before 2024 and point you at one of three things:

1. Meta's Groups API. Deprecated in Graph API v19 and removed for every version on April 22, 2024. Apps can no longer read group posts through it, even for groups they used to have access to.
2. Zapier or Make "new post in group" triggers. They were built on that API, so they went with it.
3. Facebook's own notifications. They work for one person following a group by hand, but there's no feed, no filtering, and nothing you can pipe into a tool.

What still works is reading the group the way a visitor does: a public group's posts are visible to anyone, and a data API returns them as JSON. That's what we'll use.

What you need

• A public Facebook group's link, e.g. https://www.facebook.com/groups/<group-name>. Private groups aren't covered by any public-data API, and that's the right answer: if you need a private group, use the tools Facebook gives members and admins.
• A SocialAPIs API key. The free plan includes 200 calls a month and needs no card: get one here.
• Python 3.9+ with requests, or an n8n instance.

The API call

One endpoint does the work: GET /facebook/groups/posts.

1curl -G "https://api.socialapis.io/facebook/groups/posts" \
2  -H "x-api-token: $SOCIALAPIS_API_KEY" \
3  --data-urlencode "link=https://www.facebook.com/groups/<group-name>" \
4  --data-urlencode "limit=3"

The response lists the latest posts, newest first:

1{
2  "data": {
3    "page_info": { "end_cursor": "Cg8TZXhpc3Rpbmc...", "has_next": true },
4    "posts": [
5      {
6        "details": {
7          "post_id": "3833648170210634",
8          "post_link": "https://www.facebook.com/groups/<group-name>/permalink/3833648170210634/",
9          "share_count": "0",
10          "comments_count": "0"
11        },
12        "reactions": { "total_reaction_count": 0 },
13        "values": { "text": "Selling my board game collection…", "is_media": "Photo" },
14        "user_details": { "name": "…", "profile_url": "…" }
15      }
16    ]
17  }
18}

The fields that matter for monitoring are details.post_id (to know what you've already seen), details.post_link (to open the post) and values.text (to filter and preview).

Useful parameters:

Cost: 1 credit per call with the default limit=3, and up to 3 credits at limit=9. Checking one group every hour is about 720 calls a month; the free plan covers testing, and a paid plan covers continuous monitoring (pricing).

Option 1: a Python script (about 40 lines)

This checks one group, remembers what it has seen in a small JSON file, filters by keywords if you set any, and posts new matches to a Slack channel through an incoming webhook.

1import json
2import os
3from pathlib import Path
4
5import requests
6
7API_KEY = os.environ["SOCIALAPIS_API_KEY"]
8SLACK_WEBHOOK_URL = os.environ["SLACK_WEBHOOK_URL"]
9GROUP_URL = os.environ["GROUP_URL"]
10KEYWORDS = [k.strip().lower() for k in os.environ.get("KEYWORDS", "").split(",") if k.strip()]
11SEEN_FILE = Path("seen_posts.json")
12
13
14def latest_posts():
15    response = requests.get(
16        "https://api.socialapis.io/facebook/groups/posts",
17        headers={"x-api-token": API_KEY},
18        params={"link": GROUP_URL, "limit": 9},
19        timeout=60,
20    )
21    response.raise_for_status()
22    return response.json().get("data", {}).get("posts", [])
23
24
25def main():
26    seen = set(json.loads(SEEN_FILE.read_text())) if SEEN_FILE.exists() else set()
27    first_run = not seen
28
29    for post in reversed(latest_posts()):
30        post_id = post["details"]["post_id"]
31        if post_id in seen:
32            continue
33        seen.add(post_id)
34
35        text = (post.get("values") or {}).get("text") or ""
36        if first_run or (KEYWORDS and not any(k in text.lower() for k in KEYWORDS)):
37            continue
38
39        preview = text[:300] + ("…" if len(text) > 300 else "")
40        requests.post(
41            SLACK_WEBHOOK_URL,
42            json={"text": f"New post in the group:\n{preview}\n{post['details']['post_link']}"},
43            timeout=30,
44        )
45
46    SEEN_FILE.write_text(json.dumps(sorted(seen)))
47
48
49if __name__ == "__main__":
50    main()

Run it once by hand: the first run only records what's already there, so you don't get a flood of old posts. Then schedule it, for example every hour with cron:

10 * * * * cd /path/to/monitor && SOCIALAPIS_API_KEY=... SLACK_WEBHOOK_URL=... GROUP_URL=... KEYWORDS="for sale,wanted" /usr/bin/python3 monitor.py

To watch several groups, loop over a list of URLs and keep one seen-file per group. To send email or Telegram instead of Slack, replace the requests.post to the webhook; nothing else changes.

Option 2: n8n, no code

The same workflow in n8n, which runs on n8n Cloud or self-hosted:

1. Schedule Trigger: every hour.
2. HTTP Request: GET https://api.socialapis.io/facebook/groups/posts, query link = your group URL and limit = 9. Authentication: Generic credential → Header Auth, name x-api-token, value your API key.
3. Split Out: field data.posts, so each post becomes one item.
4. Remove Duplicates: operation Remove items processed in previous executions, dedupe value {{ $json.details.post_id }}. This is n8n's built-in memory of what it has already seen, so there's no file or database to manage.
5. Filter (optional): keep items where {{ $json.values.text }} contains your keywords.
6. Slack (or Gmail, Telegram, Google Sheets): message {{ $json.values.text }} plus {{ $json.details.post_link }}.

Run it once manually first so the existing posts are recorded as "seen", then activate it. Make and Zapier can do the same with their HTTP module and a data store for the seen IDs.

Is this allowed?

What this reads is what anyone can see on a public group without logging in. A few rules keep it that way:

• Public groups only. No logins, no cookies, no access to private groups.
• Collect what you need. For monitoring, the post text and link are usually enough; don't store members' names or profiles unless your use case needs them, and if you're in the EU or UK, treat them as personal data under GDPR.
• Don't republish people's posts as your own content. Monitoring, alerting and analysis are the normal uses.

Meta's own terms restrict automated collection; read them for your use case, and keep your use to public, non-personal information where you can.

Common questions

How often should I check? Every hour suits most groups; busy buy-and-sell groups may justify every 15 minutes. Use limit=9 if a group gets more than three posts between checks.

Can I get older posts? Yes: pass page_info.end_cursor from one response as end_cursor in the next call to go further back, or use after_time and before_time to read a time range.

What about the group's details (members, description)? /facebook/groups/details returns those, and /facebook/groups/id turns a group link into its ID.

Can an AI assistant do this? Yes. With the SocialAPIs MCP server, Claude, ChatGPT or Cursor can read a group's latest posts on request ("what are people asking about in this group this week?") through the facebook_group tool.

Summary

Meta's Groups API is gone, but a public group's new posts are still one API call away. Schedule the call, keep the post IDs you've seen, and send the rest wherever your team works. Start with the free plan to test it on your group: get an API key.