Facebook Posts Scraper: Performance Analyzer

Facebook Posts Scraper — Benchmarks, Engagement and Share-of-Voice

Facebook Posts Scraper: Performance Analyzer scrapes public Facebook Page timelines and returns two connected row types: raw posts (text, reactions, comments, shares, media) and a per-page benchmark row (avgEngagement, totalEngagement, shareOfVoicePct, postingCadenceDays, growthDelta). Point it at two or more competitor pages and it compares them in one run — no Facebook login or developer account required. Social media managers, agencies reporting on client pages, and market researchers use it to see, in one dataset, who is winning share of voice and whether that lead is growing or shrinking.

What is Facebook Posts Scraper: Performance Analyzer?

It is an Apify Actor that scrapes the public post timeline of one or more Facebook Pages and turns the raw counts into a comparable performance benchmark — post volume, average engagement, share-of-voice across the set, posting cadence, and growth since your last run. No Facebook account, login, or API key is required; the Actor reads public page timelines directly through its own scraping layer.

• Targets pages by URL or plain username (nytimes, https://www.facebook.com/nasa/) — no search or category step needed
• Extracts full post detail: text, timestamp, reaction breakdown (like/love/haha/care/sad/wow/angry), comment and share counts, media, and permalinks
• Computes a per-page benchmark row: post count, average reactions/comments/shares, a weighted avgEngagement score, totalEngagement, and shareOfVoicePct across all benchmarked pages
• Tracks growth across reruns (growthDelta) using a snapshot stored under an optional campaign key
• Filters the sample by absolute or relative date range
• Optionally pulls video/reel transcripts into captionText

What data can I extract with Facebook Posts Scraper: Performance Analyzer?

Every run produces rowType: "benchmark" rows (one per page) and, unless disabled, rowType: "post" rows (one per sampled post). The benchmark row is the Actor's headline output:

Field	Example Value	Use Case
rowType	"benchmark"	Separate aggregate rows from raw post rows in the same dataset
pageName	"nytimes"	Identify which competitor the row belongs to
facebookUrl	"https://www.facebook.com/nytimes/"	Link back to the source page
postCount	10	See the sample size behind the averages
avgReactions	842.3	Average reactions per post
avgComments	156.7	Average comments per post
avgShares	92.4	Average shares per post
avgEngagement	1432.7	Weighted performance score per post
totalEngagement	14327.0	Sum of weighted engagement across the sample
shareOfVoicePct	63.42	This page's share of total engagement across the benchmarked set
postingCadenceDays	0.85	Average days between posts — publishing frequency
growthDelta	{"totalEngagementDelta": 512.3, ...}	Change vs. this page's previous run
scrapedAt	"2026-07-26T09:14:03.000Z"	Timestamp for trend tracking across runs

The benchmark row also carries a 14th key, inputUrl (a copy of facebookUrl), which isn't shown in the default table view but is present in the JSON/CSV export. When benchmarkOnly is off (default), the Actor also pushes one rowType: "post" row per sampled post, with 28 fields: facebookUrl, postId, pageName, url, time, timestamp, user, collaborators, text, captionText, likes, comments, shares, topReactionsCount, reactionLikeCount, reactionLoveCount, reactionHahaCount, reactionCareCount, reactionSadCount, reactionWowCount, reactionAngryCount, media, feedbackId, topLevelUrl, facebookId, pageAdLibrary, inputUrl, rowType.

Performance metrics

avgEngagement is a transparent weighted score computed per post as likes + 2×comments + 3×shares, then averaged over the sampled posts (maxPosts). totalEngagement sums that score across the sample. shareOfVoicePct divides each page's totalEngagement by the sum across every page in the same run (null if the whole set has zero engagement — never a fabricated value). growthDelta compares the current run's totalEngagement/avgEngagement against a snapshot stored from the page's previous run; it is null on the very first run for a page, since there is no baseline to diff against yet.

Targeting data

rowType lets you keep only benchmark rows (benchmarkOnly: true) or the full post-plus-benchmark set. pageName and facebookUrl segment results by competitor. scrapedAt timestamps each run for building a trend series. postingCadenceDays lets you group pages into fast- vs. slow-posting tiers. oldestPostDateUnified / newestPostDate narrow the sample to a specific date window before any averages are computed.

How does Facebook Posts Scraper: Performance Analyzer differ from the official Facebook API?

Meta's Graph API ties Page-level insights to page ownership: per Meta's own Graph API Page reference documentation (developers.facebook.com, checked 2026-07-26), "all users requesting access to a Page using permissions must be able to perform the MODERATE task on the Page being queried" — meaning a token only unlocks insights for pages you administer, not a competitor's. That structurally rules out cross-page benchmarking through the official API.

Feature	Facebook Graph API	Facebook Posts Scraper: Performance Analyzer
Access requirement	Page access token from a page admin/moderator	Any public Page URL or username — no login
Competitor benchmarking	Not possible for pages you don't administer	Benchmarks 2+ pages side by side in one run
Share-of-voice	Not provided	Computed automatically across the run
Growth over time	You build your own storage/diffing pipeline	Built-in growthDelta via a stored snapshot
Setup requirements	Facebook Developer app, App Review, token refresh	Provide page URLs/usernames and run
Historical window	Bound by your own pages' pagination/rate rules	Any page, filtered by oldestPostDateUnified/newestPostDate

Can you get engagement analytics for a competitor's Facebook Page?

Not through the official API. Page and post Insights require MODERATE-level access on that specific page, so an app can only pull native Insights (reach, impressions, engagement) for pages it manages — never a competitor's. This Actor covers the gap differently: it reads the same public counts (reactions, comments, shares) visible on any page's public timeline, for any page, and computes the benchmark from those. It does not and cannot recreate private metrics like reach or impressions, since those are never publicly visible regardless of method.

Use the official Graph API when you manage the page and need native Insights (reach, impressions, follower demographics). Use this Actor when you need to compare your page against pages you don't administer, using publicly visible engagement.

How to use data extracted from Facebook?

Social media managers

Put your brand's page alongside two or three direct competitors in startUrls, run weekly with a fixed snapshotKey, and watch avgEngagement, shareOfVoicePct, and growthDelta move over time. A rising shareOfVoicePct with a positive growthDelta means you're pulling engagement share away from the set; a falling one flags a competitor gaining ground before it shows up in vanity metrics like follower count. Keep maxPosts identical across pages so the averages are comparable.

Agencies benchmarking client pages

Agencies running the same benchmark for multiple clients give each campaign its own snapshotKey prefix (for example, one per client account) so growth histories never mix. Each recurring run produces a ready benchmark table — shareOfVoicePct and growthDelta per competitor — that drops straight into a client report without manual spreadsheet work.

Market research and intelligence

Run the same competitor set with benchmarkOnly: true to keep output light, then compare avgEngagement and postingCadenceDays across a whole category (news outlets, retailers, airlines) to see who posts most often and who converts posts into engagement most efficiently — two different signals that a raw follower count hides.

AI agents and automated pipelines

Because output is structured JSON keyed by rowType, an agent can poll for new benchmark rows and act on shareOfVoicePct or growthDelta crossing a threshold — flagging a competitor surge or a page recovering — without any HTML parsing.

🔼 Input sample

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Facebook Page URLs or usernames to benchmark against each other (2+ recommended for meaningful share-of-voice)	["nytimes", "https://www.facebook.com/nasa/"]
maxPosts	No	integer	Recent posts to sample per page (min 1, max 1,000,000, default 10)	20
benchmarkOnly	No	boolean	true outputs only the aggregate benchmark row per page; false (default) also outputs every raw post	false
snapshotKey	No	string	Prefix isolating this campaign's growth history from others	"q3-news-brands"
includeVideoTranscript	No	boolean	Extract video/reel captions into captionText (default false)	false
timeoutMode	No	string (enum: auto, manual)	auto scales the per-page timeout from post count; manual uses targetTimeoutSecs (default auto)	"auto"
targetTimeoutSecs	No	integer	Per-page timeout in seconds when timeoutMode is manual (min 60, max 72000, default 1200)	1200
oldestPostDateUnified	No	string (date)	Only include posts after this date — absolute (2024-01-01) or relative (7 days, 2 months)	"30 days"
newestPostDate	No	string (date)	Only include posts before this date	"2024-12-31"
proxyConfiguration	No	object	Proxy settings; prefers Apify Residential, falls back to Datacenter	{"useApifyProxy": true}

{
  "startUrls": ["nytimes", "washingtonpost"],
  "maxPosts": 20,
  "benchmarkOnly": false,
  "snapshotKey": "q3-news-brands",
  "oldestPostDateUnified": "30 days"
}

Pitfall: the benchmark is only a fair comparison when every page in startUrls is sampled with the same maxPosts. Comparing a page sampled at 10 posts against one sampled at 200 will skew avgEngagement and shareOfVoicePct toward whichever sample happens to include a viral outlier. Keep maxPosts constant across a benchmark set, and keep snapshotKey unchanged between reruns — changing it starts a new growth baseline (growthDelta resets to null).

🔽 Output sample

Results are typed, per-row JSON with a fixed schema, downloadable as JSON, CSV, or Excel, or read directly from the dataset API. One complete benchmark row:

{
  "rowType": "benchmark",
  "pageName": "nytimes",
  "facebookUrl": "https://www.facebook.com/nytimes/",
  "postCount": 10,
  "avgReactions": 842.3,
  "avgComments": 156.7,
  "avgShares": 92.4,
  "avgEngagement": 1432.7,
  "totalEngagement": 14327.0,
  "shareOfVoicePct": 63.42,
  "postingCadenceDays": 0.85,
  "growthDelta": {
    "totalEngagementDelta": 512.3,
    "avgEngagementDelta": 48.1,
    "sinceIso": "2026-07-19T10:02:11.000Z"
  },
  "scrapedAt": "2026-07-26T09:14:03.000Z",
  "inputUrl": "https://www.facebook.com/nytimes/"
}

Unless benchmarkOnly is true, the same dataset also holds one rowType: "post" row per sampled post, carrying the full post detail (text, reactions breakdown, media, permalinks) listed in the fields table above.

How do you filter and target specific posts?

There is no pre-scrape quality filter here — "performance" is the output of the benchmark itself, not an input threshold — so targeting comes down to scope and volume. Date range (oldestPostDateUnified / newestPostDate, absolute or relative) freezes the comparison to a specific window, useful for comparing pages over the same campaign period rather than whatever each happened to post most recently. Volume control is maxPosts (1 to 1,000,000 per page): it sets how deep the sample goes, and it directly drives every average and the shareOfVoicePct split, so it needs to match across pages for a fair read. benchmarkOnly is the output-volume switch — flip it on to get just the aggregate rows when you only need the scoreboard, or off to also pull every underlying post. snapshotKey segments growth history so multiple concurrent benchmark campaigns (or multiple clients) don't overwrite each other's baseline.

{ "startUrls": ["nytimes", "washingtonpost"], "maxPosts": 20, "oldestPostDateUnified": "30 days", "benchmarkOnly": true }

{ "startUrls": ["https://www.facebook.com/nasa/"], "maxPosts": 50, "includeVideoTranscript": true, "benchmarkOnly": false }

{ "startUrls": ["nytimes", "nasa"], "maxPosts": 15, "snapshotKey": "q3-news-brands", "benchmarkOnly": true }

▶️ Want to try other Facebook scrapers?

Scraper Name	What it extracts
Facebook Page Posts & Comments Scraper	Public page posts plus their full comment threads (no cross-page benchmarking)
Facebook Groups Posts Scraper: with Post Analytics	Tracks public Facebook Group posts across repeated runs, flagging new vs. previously-seen posts
Facebook Comments Scraper: Sentiment & Toxicity Analysis	Sentiment and toxicity scoring on comments under a given post or video link
Facebook Ads Library Scraper: Creative & Ad Text Details	Ad Library creatives and ad copy for competitor ad monitoring
Facebook Posts Search Scraper	Keyword-based post discovery across Facebook, instead of a fixed page list
Instagram Reels Scraper With Engagement Analytics	The same engagement-analytics approach applied to Instagram Reels
LinkedIn Post Scraper & Comments Reactions	Post-level reactions and comments for LinkedIn benchmarking

Note: Facebook Groups Posts Scraper: with Post Analytics targets Groups, not Pages, and its "analytics" is new/seen-post tracking — it does not compute cross-page share-of-voice or engagement benchmarks the way this Actor does.

How to extract Facebook data programmatically

This Actor runs as a standard Apify Actor: one API call with your token, a JSON input body, structured JSON rows back.

Python example

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("SimpleAPI/facebook-posts-scraper-performance-analyzer").call(
    run_input={
        "startUrls": ["nytimes", "nasa"],
        "maxPosts": 20,
        "benchmarkOnly": True,
    }
)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "benchmark":
        print(row["pageName"], row["avgEngagement"], row["shareOfVoicePct"])

MCP for AI agents

Apify's own MCP server exposes any Actor as a callable tool. Register it in Cursor/VS Code with:

{ "mcpServers": { "apify": { "url": "https://mcp.apify.com" } } }

or via the Apify CLI: apify mcp install cursor --tools search-actors,<your-store-username>/facebook-posts-scraper-performance-analyzer. An agent can then call the Actor directly and reason over avgEngagement/shareOfVoicePct without a separate scraping step. Compatible with Claude, Cursor, VS Code (Copilot agent mode), and other MCP-aware clients.

Export to spreadsheets or CRM

Download the dataset as CSV from the Apify Console (or via the API) and import it directly — pageName, avgEngagement, shareOfVoicePct, and growthDelta.totalEngagementDelta map cleanly to CRM or spreadsheet columns for a recurring competitor scorecard.

Is it legal to scrape Facebook posts?

Yes — this Actor reads posts and engagement counts published on public Facebook Pages, which are public by nature and not gated behind a login. That data is business/public content, governed by Facebook's Terms of Service and database-rights considerations rather than personal-data law. Two fields can carry personal data: user (the profile name/ID behind a post, mainly a Page's own identity but potentially an individual profile if you target a personal profile URL) and collaborators (co-author profiles tagged on a post). If your startUrls include personal profiles or you store collaborators, treat that subset under GDPR/CCPA. Consult legal counsel for commercial applications involving bulk storage of personal data.

❓ FAQ

Does the benchmark reflect a page's whole history, or just recent posts?

Just recent posts — postCount and every average are computed only over the maxPosts most recent posts sampled in that run, not the page's full history. scrapedAt marks when the snapshot was taken; re-run to refresh it.

Can I get raw post text and media along with the benchmark?

Yes. Unless benchmarkOnly is true, the dataset holds one rowType: "post" row per sampled post — full text, reactions breakdown, media, and permalink — alongside the rowType: "benchmark" rows.

How accurate is the engagement data?

It reflects the exact reaction, comment, and share counts visible on the public page at scrape time. Facebook's own displayed counts can lag slightly server-side, so for reporting-critical numbers, spot-check against the live page.

How many posts can I get per run?

Up to 1,000,000 posts per page (maxPosts, default 10), across as many pages as you list in startUrls. There's no separate overall row cap in the input schema.

How is "performance" actually calculated?

avgEngagement is likes + 2×comments + 3×shares, averaged over the sampled posts — a transparent formula, not a black-box or Facebook-native score. shareOfVoicePct is each page's totalEngagement divided by the sum across every page in that run. Both are computed from the same counts visible in the post rows, so they're cross-checkable against the raw data.

How do I keep growth tracking accurate across reruns?

Use the same snapshotKey prefix and the same maxPosts value every time you re-run a given competitor set. growthDelta diffs against a stored snapshot keyed by that prefix plus the page name; changing the prefix starts a new baseline, and growthDelta returns to null until the next run.

Does it work with Claude, ChatGPT, and AI agent frameworks?

Yes. It's callable as a standard Apify Actor run via apify-client or a plain HTTP API call from any agent framework, and it's also reachable through Apify's MCP server (https://mcp.apify.com) as a registered tool.

How does it compare to other Facebook scrapers in this catalogue?

Unlike a plain page-and-comments scraper, it adds cross-page share-of-voice and stateless growth tracking on top of the raw post export — the raw post fields overlap, but the benchmark rows (avgEngagement, shareOfVoicePct, growthDelta) do not exist in the plain post scraper.

Can I use it without a Facebook API key or developer account?

Yes. You only need Facebook Page URLs or usernames and an Apify account with proxy access — no Facebook login, API key, or developer app is required.

Conclusion

Facebook Posts Scraper: Performance Analyzer turns a list of Facebook Page URLs into a side-by-side engagement benchmark — post-level detail plus a per-page score, share-of-voice, and cross-run growth, all in one fixed JSON schema. It's built for anyone comparing pages they don't administer, which the official Graph API can't do. Configure your competitor set and run it directly from the Apify Console, or call it programmatically with apify-client to fold the benchmark into your own reporting pipeline.