Facebook Pages Scraper By Category & Location Filter

Facebook Pages Scraper — Filter by Category, Location & Rating

Scrape public Facebook pages from a list of URLs or usernames, then keep only the ones that match a category allow-list, a location allow-list, a minimum recommend rating, and a minimum follower count — non-matching pages are dropped before they ever hit your dataset. Every response is structured JSON with contact details, ratings, follower counts, and Ad Library status, ready to pass to an LLM, load into a CRM, or feed a monitoring pipeline. No Facebook login or cookies required. Point it at a list of pages once, or run it on a schedule to keep a filtered, always-current list of the businesses that actually meet your criteria.

What is Facebook Pages Scraper By Category & Location Filter?

It's a two-stage Facebook page scraper: stage one fetches each URL in your pageUrls list and parses the page's own embedded JSON and meta tags (no headless browser, no login); stage two runs the scraped rows through a post-scrape filter — category, location, minimum rating, minimum followers — and drops anything that doesn't match before it's written to the dataset. That filter stage, with an AND/OR match mode you control, is what none of the general-purpose Facebook page scrapers on the Apify Store do: they return one record per URL you give them, full stop, leaving you to filter the export yourself. This Actor does the filtering for you, server-side, before you're charged for a row. No Facebook account, cookies, or login is required — it reads the same public HTML any visitor's browser would load.

Capabilities:

• Scrapes public page data — name, categories, address, phone, email, website, follower/like counts, recommend rating and review count, Instagram link, profile/cover photos, page ID, creation date, and Ad Library / business-active status.
• Category allow-list filter — case-insensitive match against the page's category / categories.
• Location allow-list filter — case-insensitive match against the page's address (with a fallback to the meta-description "info" line for pages that expose no structured address).
• Minimum rating and minimum follower thresholds — numeric cutoffs applied to ratingOverall and followers.
• AND / OR filter combination (filterMatchMode) — require every active filter to match, or just one.
• Automatic residential-proxy retries — up to three fresh Apify residential sessions per page before a URL is marked failed.

🧩 What data can you get with this Facebook page scraper?

Every scraped page can surface identity and branding fields, contact and location fields, audience and rating fields, social/business-status fields, and the filter outcome itself. Which of these are populated depends on what the page owner has made public — Facebook shows different intro-card sets to different pages.

Result type	Extracted fields	Primary use case
Identity & branding	title, pageName, pageId, category, categories, intro, profilePictureUrl, coverPhotoUrl, profilePhoto	Populate a directory entry or CRM record per business
Contact & location	address, addressUrl, phone, email, website, websites	Lead lists, local-business outreach, territory mapping
Audience & reputation	followers, followings, likes, rating, ratingOverall, ratingCount, info	Ranking and thresholding pages by size and reputation — this feeds minFollowers / minRating
Social & business status	instagram, alternativeSocialMedia, businessHours, creationDate, adStatus, pageAdLibrary.isBusinessPageActive, pageAdLibrary.businessId	Competitive monitoring, ad-activity tracking
Filter outcome & run metadata	facebookUrl, pageUrl, success	Reconciling which input URLs made it into the filtered output

Category, location, rating & follower filtering

This is the section that separates this Actor from a plain page scraper. filterCategories and filterLocations are case-insensitive substring allow-lists checked against fields the base scrape already produced — no second request, no extra charge for the filter itself. minRating and minFollowers are numeric floors checked against ratingOverall and followers. filterMatchMode decides whether a page needs to satisfy all of the filters you set ("all", the default) or just one ("any"); filters you leave empty are ignored either way. A page that fails the active filters is simply never pushed to the dataset — you are not charged for rows you don't want. A minimal filtered record looks like:

{
  "facebookUrl": "https://www.facebook.com/copperkettleyqr",
  "category": "Pizza place",
  "categories": ["Pizza place", "Restaurant"],
  "address": "1953 Scarth St, Regina, SK, Canada",
  "ratingOverall": 94,
  "followers": 2900,
  "success": true
}

Set filterCategories: ["pizza"], filterLocations: ["Regina"], minRating: 80, minFollowers: 1000, filterMatchMode: "all" and this row is kept because it satisfies every one of those four conditions.

Ratings and review signals

rating is the raw text Facebook renders ("94% recommend (202 Reviews)"), parsed and re-split into ratingOverall (an integer percentage, 0–100) and ratingCount (the number of reviews behind that percentage). Not every page carries a recommend rating — Facebook only shows it on pages that have opted into reviews and collected enough of them — so both fields are null when the page doesn't expose it. These are the two fields minRating filters against, so a page with no rating is always dropped when minRating is set above 0.

One edge case worth knowing if you're reading these fields directly rather than relying on the filter: a page with an exact 0% recommend score or 0 reviews is indistinguishable in the output from a page with no rating widget at all — both come through as null. This has no effect on the minRating filter itself (a genuine 0% page would fail any minRating > 0 threshold the same way a missing rating does), but if you're consuming ratingOverall/ratingCount outside the filter, treat null as "no rating data available," not strictly "zero." priceRange has its own normalization quirk: Facebook's raw price indicator ($, ££, or a plain digit) is rewritten to a run of $ characters matching the symbol count, so a UK page showing ££ in its price range comes through as priceRange: "$$" — the count of symbols is preserved, the original currency is not.

How does this differ from the Facebook Graph API?

Meta's Graph API Page reference can return page fields, but only for pages you administer or have been granted a valid Page Access Token for, and most fields beyond a small public set require App Review before Meta approves your app for them. There is no supported Graph API endpoint for discovering and filtering arbitrary third-party public pages by category, location, rating, and follower count in one call — you would need the page ID or a token first. This Actor works the other way around: give it a list of public page URLs, no token or app review needed, and it returns the publicly rendered page data, filtered server-side.

Feature	Facebook Graph API	This Actor
Access requirement	Page Access Token + App Review for most fields	None — reads public HTML
Arbitrary third-party pages	Restricted to pages you administer or that grant access	Any public page URL or username
Category/location/rating/follower filtering	Not a built-in query capability	Built in — filterCategories, filterLocations, minRating, minFollowers
Setup requirements	Facebook Developer app, review process, token management	Apify account, run the Actor
Output schema	Field graph you must assemble per field	One flat JSON row per page, pre-filtered

The Graph API is the right tool if you already own or administer the pages in question and want a first-party, ToS-compliant integration into your own app. This Actor is the right tool when you need to survey pages you don't own — competitor lists, prospect lists, local-business directories — and get back only the ones that meet a category, location, rating, or follower bar.

Why not build this yourself? Facebook's page markup isn't a stable public schema — the data this Actor needs lives in several different embedded JSON blocks (best_description, profile_tile_sections GraphQL fragments) plus regex fallbacks against the rendered HTML for fields those blocks sometimes omit, and Facebook's block/CAPTCHA response varies enough that a single-request scraper without proxy rotation will fail intermittently on pages that would otherwise load fine in a browser. That's the maintenance burden a from-scratch script inherits: parser paths for every field, retry-and-rotate logic for blocks, and re-testing every time Facebook ships a markup change. This Actor absorbs that so your input is a list of URLs and a filter, not a scraping pipeline you maintain.

How to scrape Facebook pages with this filter tool?

1. Open Facebook Pages Scraper By Category & Location Filter on the Apify platform (Console or Store) and go to the Input tab.
2. Add your page URLs or bare usernames to pageUrls, one per line — full links like https://www.facebook.com/copperkettleyqr or short forms like copperkettleyqr both work.
3. Set the filters you want: filterCategories, filterLocations, minRating, minFollowers, and filterMatchMode to decide whether all of them must match or just one. Leave any of them empty to skip that filter.
4. Click Start. Each page is fetched through Apify residential proxy, parsed, and immediately tested against your active filters.
5. Download the matched pages from the Storage tab as JSON, CSV, Excel, XML, or HTML, or pull them with the Apify API / apify-client.

How to run multiple queries in one job

There's no per-query loop to manage — pageUrls is itself a list, so scanning 200 pages and applying the same filter set to all of them is one run. scanLimit caps how many entries from that list are actually scraped (in list order) before filtering, from 1 up to 10,000, default 10. Filtered-out pages still count against that cap, so if you want the filter to have a large enough pool to work with, raise scanLimit to at least the number of URLs you supply.

⬇️ Input

All eight fields are optional in the schema, but you must supply at least one URL in pageUrls (or the legacy startUrls) or the run fails immediately.

Parameter	Required	Type	Default	Constraints
pageUrls	No	array of strings	—	stringList editor. Full Facebook URLs or bare usernames, one per line. Backward-compatible: a base startUrls field (array of {url} objects or strings) is still accepted if pageUrls is empty.
filterCategories	No	array of strings	[]	stringList editor. Case-insensitive allow-list matched against category / categories. Empty = filter skipped.
filterLocations	No	array of strings	[]	stringList editor. Case-insensitive allow-list matched against address (and the description "info" line as fallback). Empty = filter skipped.
minRating	No	integer	0	minimum: 0, maximum: 100. Keeps only pages whose ratingOverall is ≥ this value. 0 = filter off. Pages with no rating are dropped once this is > 0.
minFollowers	No	integer	0	minimum: 0, no maximum. Keeps only pages whose followers is ≥ this value. 0 = filter off. Pages with no follower count are dropped once this is > 0.
filterMatchMode	No	string (enum)	"all"	"all" (page must match every active filter — AND) or "any" (page needs only one active filter to match — OR).
scanLimit	No	integer	10	minimum: 1, maximum: 10000. Caps how many input URLs are scraped, in list order, before filtering. Backward-compatible: a base maxPages field is still accepted if scanLimit is absent. Out-of-range or non-numeric values are silently clamped to the 1–10,000 window rather than rejected.
proxyConfiguration	No	object	{"useApifyProxy": true}	proxy editor. This Actor always issues requests through Apify RESIDENTIAL proxy — datacenter or custom groups selected here are ignored. Up to 3 fresh residential sessions are tried per page before it's marked failed. Proxy access must be enabled on your Apify plan.

Example input

{
  "pageUrls": [
    "https://www.facebook.com/copperkettleyqr",
    "ChrisBrecheensWritingAboutWriting"
  ],
  "filterCategories": ["restaurant", "pizza"],
  "filterLocations": ["Regina"],
  "minRating": 80,
  "minFollowers": 1000,
  "filterMatchMode": "all",
  "scanLimit": 25,
  "proxyConfiguration": { "useApifyProxy": true }
}

This scans up to 25 pages from the list and keeps only the ones that are a restaurant/pizza place and located in Regina and rated ≥80% and have ≥1,000 followers, since filterMatchMode is "all".

Common pitfall: scanLimit caps the input list before filtering, not the number of results. If you set scanLimit: 10 against a 500-URL list with a strict minFollowers filter, the Actor only ever evaluates the first 10 URLs — raise scanLimit to cover the pool you actually want filtered, not the number of matches you expect back.

Backward compatibility: if you're migrating a task built against the base scraper this Actor is derived from, startUrls and maxPages still work — pageUrls is checked first and startUrls used only if it's empty; scanLimit is checked first and maxPages used only if scanLimit is absent. You don't need to rewrite existing task input to adopt the new field names, but new tasks should use pageUrls / scanLimit since that's what the input UI and this documentation reflect going forward.

⬆️ Output

Results are written as one JSON object per matching page to the Actor's default dataset — pages that fail your filters, or fail to scrape, are not billed rows. Export from the Storage tab as JSON, CSV, Excel, XML, HTML, or RSS, or pull it through the Apify API.

Scraped page records

[
  {
    "facebookUrl": "https://www.facebook.com/copperkettleyqr",
    "categories": ["Pizza place", "Restaurant"],
    "info": ["The Copper Kettle Restaurant, Regina. 2,661 likes", "68 talking about this."],
    "likes": 2661,
    "priceRange": "$$",
    "title": "The Copper Kettle Restaurant",
    "address": "1953 Scarth St, Regina, SK, Canada",
    "pageId": "100064027242849",
    "pageName": "copperkettleyqr",
    "pageUrl": "https://www.facebook.com/copperkettleyqr",
    "intro": "Longstanding local restaurant serving Regina since 1979.",
    "websites": ["https://thecopperkettle.online"],
    "phone": "+1 306-525-3545",
    "email": "copperkettle.events@gmail.com",
    "alternativeSocialMedia": null,
    "website": "thecopperkettle.online",
    "services": null,
    "rating": "94% recommend (202 Reviews)",
    "followers": 2900,
    "followings": null,
    "profilePictureUrl": "https://scontent.xx.fbcdn.net/v/t39.30808-1/copperkettle_profile.jpg",
    "coverPhotoUrl": "https://scontent.xx.fbcdn.net/v/t39.30808-6/copperkettle_cover.jpg",
    "profilePhoto": "https://www.facebook.com/photo/?fbid=100064027242849",
    "ratingOverall": 94,
    "ratingCount": 202,
    "category": "Pizza place",
    "addressUrl": "https://maps.google.com/maps?q=1953+Scarth+St%2C+Regina%2C+SK%2C+Canada",
    "instagram": [{ "username": "copperkettleyqr", "url": "https://www.instagram.com/copperkettleyqr" }],
    "businessHours": null,
    "creationDate": "March 04, 2011",
    "adStatus": null,
    "pageAdLibrary": { "isBusinessPageActive": true, "businessId": "851606664870954" },
    "success": true
  },
  {
    "facebookUrl": "https://www.facebook.com/ChrisBrecheensWritingAboutWriting",
    "categories": ["Blogger", "Writer"],
    "info": ["Writing About Writing. 1,148,094 likes", "68,836 talking about this."],
    "likes": 1148094,
    "priceRange": null,
    "title": "Writing About Writing",
    "address": null,
    "pageId": "100077736131324",
    "pageName": "ChrisBrecheensWritingAboutWriting",
    "pageUrl": "https://www.facebook.com/ChrisBrecheensWritingAboutWriting",
    "intro": "Macros, memes, quotes, puns and more as well as daily updates from the blog this page promotes.",
    "websites": ["https://chrisbrecheen.blogspot.com/"],
    "phone": null,
    "email": "chris.brecheen@gmail.com",
    "alternativeSocialMedia": null,
    "website": "chrisbrecheen.blogspot.com",
    "services": null,
    "rating": null,
    "followers": 1219522,
    "followings": null,
    "profilePictureUrl": "https://scontent.fios2-1.fna.fbcdn.net/v/t39.30808-1/writingaboutwriting_profile.jpg",
    "coverPhotoUrl": "https://scontent.fios2-1.fna.fbcdn.net/v/t39.30808-6/writingaboutwriting_cover.jpg",
    "profilePhoto": "https://www.facebook.com/photo/?fbid=100077736131324",
    "ratingOverall": null,
    "ratingCount": null,
    "category": "Blogger",
    "addressUrl": null,
    "instagram": [],
    "businessHours": null,
    "creationDate": "October 07, 2012",
    "adStatus": "This Page is not currently running ads.",
    "pageAdLibrary": { "isBusinessPageActive": false, "businessId": "290072384435404" },
    "success": true
  },
  {
    "facebookUrl": "https://www.facebook.com/UNclimatechange",
    "categories": ["Organization", "Government Organization"],
    "info": ["UN Climate Change, Bonn, Germany. 494,043 likes", "807 talking about this."],
    "likes": 494043,
    "priceRange": null,
    "title": "UN Climate Change | Bonn",
    "address": "Platz der Vereinten Nationen 1, Bonn, Germany",
    "pageId": "100067499490396",
    "pageName": "UNclimatechange",
    "pageUrl": "https://www.facebook.com/UNclimatechange",
    "intro": "The official Facebook page of the United Nations Framework Convention on Climate Change (UNFCCC).",
    "websites": ["https://maps.google.com/maps?q=Platz+der+Vereinten+Nationen+1%2C+Bonn%2C+Germany", "http://unfccc.int/"],
    "phone": "+49 228 8151000",
    "email": null,
    "alternativeSocialMedia": null,
    "website": "unfccc.int",
    "services": null,
    "rating": "94% recommend (839 Reviews)",
    "followers": 514363,
    "followings": null,
    "profilePictureUrl": "https://scontent.fsxb1-1.fna.fbcdn.net/v/t39.30808-1/unfccc_profile.jpg",
    "coverPhotoUrl": "https://scontent.fsxb1-1.fna.fbcdn.net/v/t39.30808-6/unfccc_cover.jpg",
    "profilePhoto": "https://www.facebook.com/photo/?fbid=100067499490396",
    "ratingOverall": 94,
    "ratingCount": 839,
    "category": "Organization",
    "addressUrl": "https://maps.google.com/maps?q=Platz+der+Vereinten+Nationen+1%2C+Bonn%2C+Germany",
    "instagram": [],
    "businessHours": null,
    "creationDate": "January 26, 2009",
    "adStatus": "This Page is not currently running ads.",
    "pageAdLibrary": { "isBusinessPageActive": false, "businessId": "63044235866" },
    "success": true
  }
]

Two output-shape details worth knowing before you parse this: website (singular) is the page's declared site, reduced to a bare domain — the more reliable field to key on. websites (plural) is a raw collector array and can also contain the page's Google Maps address link and/or its Instagram link alongside its actual external site, as shown in the UN Climate Change record above — treat it as "external links found on the page," not strictly "websites." instagram is the clean, structured version if all you want is the Instagram handle and URL. A page with no rating shows rating, ratingOverall, and ratingCount as null rather than 0 — Facebook simply doesn't render a rating widget for pages that haven't opted in.

How can I use the filtered Facebook page data?

• 🏢 Local-business and lead-gen teams: feed filterCategories + filterLocations with your target verticals and cities, then hand the resulting email / phone / website fields straight to an outreach sequence — no manual triage of out-of-territory or wrong-category pages.
• 🤖 AI engineers and LLM developers: treat this as a grounding source — an agent calls the Actor with a category/location/rating query, gets back structured JSON, and passes the matched pages directly into a prompt as context instead of hallucinating business details.
• 📊 Market and competitive researchers: run the same pageUrls list with no filters to get a full baseline, then apply minFollowers / minRating thresholds on the exported data to see how many competitors clear a bar you set — repeatable, since the filter logic is deterministic against the same fields every run.
• 📣 Growth and partnerships teams: use adStatus and pageAdLibrary.isBusinessPageActive across a filtered set to spot which matching businesses are actively advertising on Facebook, a signal for ad-spend-based outreach.
• 🗂️ Directory and marketplace operators: run the same filterCategories + filterLocations pair against a large pageUrls pool on a recurring schedule to keep a category-and-city-scoped listings page populated with pages that still meet your quality bar (minRating, minFollowers) without manually re-vetting every entry.

🔁 How do you monitor filtered Facebook pages over time?

Monitoring here means re-running the same pageUrls + filter configuration on a schedule and diffing the matched set between runs, rather than diffing a single page's history. Because the filter is deterministic — same category/location/rating/follower inputs produce the same keep/drop decision against the same scraped data — a page moving in or out of your filtered dataset between runs is itself the signal: a competitor crossing your minFollowers threshold, a business changing its listed category, or a page's ratingOverall dropping below your minRating floor. The fields worth diffing run-over-run are followers, ratingOverall, ratingCount, category/categories, adStatus, and pageAdLibrary.isBusinessPageActive — everything else on a stable page rarely changes between scrapes. A practical loop: schedule a run against the same pageUrls list weekly, export both runs' datasets, join on pageId, and alert on any row that newly entered or newly left the filtered set, or whose followers/ratingOverall crossed your threshold since last time. This Actor has no built-in scheduler of its own — use Apify's platform-level Schedules (cron-based, configured in the Apify Console) to trigger recurring runs, and a dataset webhook to get notified as soon as a run's filtered output is ready.

Integrate this Facebook pages scraper and automate your workflow

This Actor works with any language or tool that can call the Apify API — there's no separate signup or API key beyond your Apify account token.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "pageUrls": ["https://www.facebook.com/copperkettleyqr"],
    "filterCategories": ["restaurant"],
    "minRating": 80,
    "filterMatchMode": "all",
    "scanLimit": 25,
}

run = client.actor("<YOUR_USERNAME>/facebook-pages-scraper-by-category-location-filter").call(run_input=run_input)

for page in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(page["title"], page["ratingOverall"], page["followers"])

Scheduled monitoring and delivery

There's no webhook or push mechanism built into the Actor itself. Set up recurring runs with Apify's Schedules feature (cron syntax, configured per Actor task in the Console), and attach a dataset webhook if you want an HTTP callback fired the moment a scheduled run's filtered dataset is ready — both are platform-level Apify features, available to any Actor run under your account.

Is it legal to scrape Facebook pages?

Yes — public Facebook page data is publicly accessible information, and this Actor returns only what any visitor sees without logging in; it does not access private profiles, private groups, or gated content. In hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), the court held that scraping data a website has made publicly accessible does not violate the Computer Fraud and Abuse Act — the closest analogous precedent for automated collection of public-facing pages like this Actor's target. Facebook Pages exist specifically to represent businesses, organizations, and public figures, so the data model here is closer to a business directory or catalog than to personal-profile data — the applicable framework is Facebook's own Terms of Service (which govern automated access to the platform, separately from data-protection law) rather than GDPR/CCPA, which are built around personal data about individuals. That said, some scraped fields — a listed contact email, a phone number — can qualify as personal data under GDPR/CCPA if the page belongs to a sole proprietor or individual, so apply the same data-minimization discipline you would to any contact list you build. Scraping for one-off research and monitoring carries a different risk profile than scraping at scale for AI training or resale. Consult your legal team for commercial use cases involving bulk data storage or resale of scraped data.

❓ Frequently asked questions

What Facebook URL formats does pageUrls accept?

Both full URLs (https://www.facebook.com/copperkettleyqr) and bare usernames (copperkettleyqr) work — the Actor normalizes bare usernames to https://www.facebook.com/<username> before fetching. Trailing slashes and surrounding whitespace are stripped automatically.

How does filterMatchMode change my results?

"all" (the default) requires a page to satisfy every filter you've actually set — leave filterLocations empty and it's simply excluded from the AND, not treated as a failure. "any" keeps a page if it satisfies at least one of the filters you set. If you only set one filter, both modes behave identically.

Does this Actor require a Facebook login?

No. It fetches each page's public HTML the way an unauthenticated visitor's browser would, through Apify residential proxy, and parses the JSON Facebook embeds in that response. There is no cookie, session, or credential input in the schema — nothing to log in with and nothing to leak.

How does the category and location filtering actually match?

Both are case-insensitive substring matches, not exact matches. filterCategories: ["cafe"] matches a page whose category/categories contains "cafe" anywhere, including as part of a longer category name. filterLocations checks address first, falling back to the page's meta-description "info" line for pages that expose no structured address field — useful for pages that list a city in their bio but not a formal street address.

How many pages does this Actor return per run?

Up to scanLimit pages are scraped (1–10,000, default 10), but the number that actually reach your dataset can be lower — every scraped page still has to pass your active filters, and a run with strict filters and no matches returns zero rows. That's treated as a valid, successful outcome, not an error.

What happens if a page fails to scrape?

It's retried up to three more times on a fresh residential proxy session if the failure looks like a block (429, CAPTCHA, login redirect, 401/403). If it still fails, the page is excluded from your filtered dataset and never charged. When you have no filters configured at all, a failed page is still pushed to the dataset as an uncharged row with success: false and an error message, so you can see what didn't come through; once you turn on any category/location/rating/follower filter, that visibility drops to the run log only — failed pages under an active filter configuration don't appear in the dataset at all, matched or not. Check the run log for "Failed:" entries if you're running with filters and page counts look lower than expected.

How do I monitor filtered pages over time?

Schedule the same pageUrls + filter configuration to run repeatedly with Apify's Schedules feature, export each run's dataset, and diff on pageId — see the monitoring section above for the specific fields worth tracking (followers, ratingOverall, ratingCount, category, adStatus).

Does this Actor work with Claude, ChatGPT, and AI agent frameworks?

It's callable as a standard HTTP endpoint through the Apify API by any agent framework that can make a REST call — pass your filter criteria in, get structured JSON back, and ground the agent's answer in the matched pages rather than a model's memory of what a business looks like online. There is no dedicated MCP server documented for this Actor.

How does this compare to other Facebook page scrapers?

Checked on the Apify Store, 2026-07-26: apify/facebook-pages-scraper returns one record per input URL with no built-in category/location/rating/follower filtering — you'd export everything and filter client-side; its listing also documents JSON/CSV/Excel/HTML export and Node/Python API access. cleansyntax/facebook-pages-scraper accepts a manual URL array or .txt upload and returns a fixed field set (page_id, name, address, categories, email, phone, website, followers, likes, price_range, rating, image, cover_image) with no post-scrape filtering documented. curious_coder/facebook-post-scraper targets posts, groups, and search rather than page profiles, and documents cookie-based login as optional-but-recommended. This Actor is the only one of the three with a built-in category/location allow-list plus numeric rating/follower thresholds and an AND/OR combination mode, applied before you're charged for a row.

Can I use this without managing proxies or a Facebook account?

Yes. The Actor always routes requests through Apify residential proxy automatically — the proxyConfiguration input exists for the UI, but datacenter or custom proxy-group selections there are ignored and residential is used regardless. You only need an Apify account with proxy access enabled on your plan; no Facebook account, cookies, or API token of your own is required.

💬 Your feedback

Found a bug, or a field that's coming back empty when it shouldn't? Let us know through the Actor's Issues tab on the Apify Console, or reach out to Scrapier support directly — reports like this are what keep the parsing logic current as Facebook's page markup changes.