Facebook Pages Scraper

Facebook Pages Scraper — Contacts, Categories and Page Metrics

Facebook Pages Scraper extracts public Facebook Page data from page URLs or usernames and returns one typed JSON row per Page: name, categories, intro, likes, followers, email, phone, address, websites, Instagram link, business hours, rating summary, photos, page ID and creation date. No Facebook login, no cookies, no HTML parsing — 33 stable keys per row, exported as JSON, CSV or Excel. Below you will find every input parameter, every output key, and the two run rules that decide whether a Page comes back filled or empty.

⚠️ Two run rules to read before your first run

Both of these are how the Actor actually behaves, and neither is obvious from the input form.

1. This Actor always uses Apify Residential proxy, and it ignores the proxy tier you pick. The proxyConfiguration input is rendered so that proxy usage stays visible and billed transparently in your account, but the code builds its own configuration — {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]} — for every request. Datacenter selections or custom proxy groups you enter in that field are not used. Facebook serves logged-out Page HTML poorly to datacenter ranges, so this is deliberate rather than an oversight. The consequence: residential proxy access must be enabled on your Apify plan. If the Actor cannot create a residential proxy URL, the run fails immediately with a status message telling you to check your proxy subscription and account limits — it does not silently fall back to a direct connection.

2. Every page you submit produces a dataset row, and every row is charged as row_result — including pages that failed. There are no uncharged accounting rows and no hidden log-only rows. A page that could not be fetched is pushed as a three-key row with "success": false and an error string. That is honest accounting, but it means you should filter on the flag before you use the data:

good = [row for row in rows if row.get("success")]

In a dataset export, the equivalent filter is success == true. The success field is in the default dataset view for exactly this reason.

What is Facebook Pages Scraper?

Facebook Pages Scraper is an Apify Actor that turns a list of Facebook Page URLs or usernames into a clean, one-row-per-Page dataset. It fetches the public, logged-out version of each Page, reads the JSON payloads Facebook embeds in its own <script type="application/json"> blocks, and flattens them into 33 fixed keys covering three things at once: the Page record itself, its contact block, and its business and about metadata.

No Facebook account, login, cookie or session is required. Everything returned is what an anonymous visitor already sees on the Page. This Actor collects page-level details only — it does not scrape individual posts, reviews, comments, photos or followers.

• Scrape Page records — title, page ID, vanity name, intro, categories, likes, followers, followings, creation date
• Scrape Page contact blocks — email, phone, address, Google Maps link, website list, Instagram profile
• Scrape business and about metadata — price range, business hours, services, percent-recommend rating and review count, ad status
• Scrape Page media — profile picture, cover photo, profile photo permalink
• Export as JSON, CSV or Excel; no proxy management, no parsing, no selectors on your side

What data does Facebook Pages Scraper collect?

Every successful row carries four groups of data — who the Page is, how to reach it, how Facebook classifies and rates it, and what it looks like — plus a run-status flag.

Data Type	Key Fields	JSON Field Names
Page record	Page name, numeric ID, vanity handle, canonical URL, intro text, meta description lines	title, pageId, pageName, facebookUrl, pageUrl, intro, info
Contact block	Public email, phone, street address, real Google Maps link, all outbound links, website domain, Instagram account	email, phone, address, addressUrl, websites, website, instagram, alternativeSocialMedia
Category and about metadata	Category list and primary category, price range, business hours, services line, ad status	categories, category, priceRange, businessHours, services, adStatus
Audience and rating signals	Likes, followers, followings, percent-recommend text, percent value, review count	likes, followers, followings, rating, ratingOverall, ratingCount
Media and identity	Profile picture URL, cover photo URL, profile photo permalink, page creation date	profilePictureUrl, coverPhotoUrl, profilePhoto, creationDate
Ad Library link	Whether the business Page is active, Ad Library business ID	pageAdLibrary.isBusinessPageActive, pageAdLibrary.id
Run status	Whether this row is real data or a failed fetch	success, error

Three naming details worth mapping correctly on your side, because they are easy to get wrong:

• website is a bare domain (humansofnewyork.com), not a URL. The full URLs live in the websites array, which also absorbs the Google Maps link and the Instagram link when the Page publishes them.
• ratingOverall is Facebook's percent-recommend figure, not a 1–5 star score. rating is the human-readable string it was parsed from.
• followings is spelled with the trailing s — it mirrors Facebook's own followings_count field and is preserved rather than renamed to following.

Need more Facebook data?

This Actor stops at the Page record. If you need what happens on the Page, Facebook Page Engagement Analytics Scraper covers post-level engagement for the same Pages. For communities rather than Pages, Facebook Groups Search Scraper With Group Details Rules, Facebook Group Rules Topics Extractor and Facebook Group Active Members Extractor cover discovery, group metadata and member extraction. Facebook Search Scraper WhatsApp Contact Leads and Facebook Videos Scraper Commenters Reactors Sharers extend the contact and audience side.

How does Facebook Pages Scraper differ from the official Facebook Graph API?

Meta's Graph API is the supported route and it returns far more than public Page metadata — but it is built around Pages you or your client control, not around arbitrary Pages you want to research.

Feature	Facebook Graph API (Pages API)	Facebook Pages Scraper
Meta developer app required	Yes	No
Access token required	Yes — a Page access token, issued to a user with a role on that Page	No token, no login, no cookie
Reading Pages you do not administer	Restricted; requires the relevant permissions and Meta's App Review	Any publicly visible Page
App Review / business verification	Required for the permissions that unlock Page fields	Not applicable
Available fields	Meta's documented Page node fields, gated per permission	The 33 keys documented below, read from the public page
Rate limiting	Meta's published platform rate limits apply	Sequential fetches with a pause between pages, as implemented
Setup time	App creation, permission requests, review submission	Paste URLs, press Start

Exact permission names, field availability and current rate-limit terms are published by Meta and change over time — check the Page node reference and the Permissions reference before choosing between the two. Numbers are deliberately not reproduced here.

Use the Graph API when you administer the Pages, need write access, or need engagement and insights data with contractual guarantees. Use Facebook Pages Scraper when you need public metadata and contact details for Pages you have no relationship with — competitor research, local business discovery, directory building.

Why do developers and teams scrape Facebook Pages?

A Facebook Page is often the most complete public record a small business maintains — more current than its website, and frequently the only place its phone number and opening hours appear. That makes Page data useful to four different readers for four different reasons.

For lead generation and sales teams

Local businesses, tradespeople and independent operators put their working contact details on their Page rather than behind a contact form. A run over a list of Pages in one vertical returns email, phone, address and websites in a single pass, with category and businessHours available as qualification filters. Because website is normalised to a bare domain, it deduplicates cleanly against an existing CRM, and success tells you which Pages produced nothing, so your outreach list is not padded with blanks.

For marketers and brand teams

Competitor and partner monitoring works well here because the same 33 keys come back every run. Re-run the same startUrls on an Apify schedule and diff likes, followers, ratingOverall and ratingCount per pageId to see which competitor Pages are growing and which are accumulating negative sentiment. adStatus and pageAdLibrary.isBusinessPageActive flag Pages that are currently running ads, which is a useful signal for spotting a competitor campaign before it shows up in your own channel metrics.

For researchers and analysts

Only publicly visible Page details are collected — nothing behind a login wall, nothing from a personal profile's friends-only surface. That makes the output workable for market-structure research: categories, address, priceRange and creationDate across a sampled set of Pages describe how a local sector is composed and how long its participants have existed. info preserves Facebook's own meta description line verbatim, which is useful when you need the unedited self-description rather than a parsed field.

For developers and AI engineers building data products

Every row is typed JSON with fixed keys, so it drops straight into a pipeline with no parsing step. Index title, intro, categories and services into a vector store and an agent can answer "which Pages in this list are restaurants with a public phone number" against live data. For a directory or a lead product, pageId is the stable join key, facebookUrl the canonical link, and success the filter that keeps failed fetches out of your database.

How to scrape Facebook Pages (step by step)

Facebook Pages Scraper runs on Apify. Start it from the Apify Console, or call it through the Apify API with apify_client.

1. Open Facebook Pages Scraper on Apify and click Try for free
2. Paste your Pages into 🔗 Your Facebook pages (URLs or usernames) (startUrls) — one per line. This is the only required input
3. Set 🔢 How many pages this run should cover (maxPages) to at least the number of URLs you pasted — anything past that number is dropped, not queued
4. Leave the proxy section on. Residential is used regardless of what you select, and proxy access must be enabled on your plan
5. Click Start, then export the dataset as JSON, CSV or Excel — or read it through the Apify API

Both formats are accepted in startUrls: a full link such as https://www.facebook.com/copperkettleyqr, or a bare username such as copperkettleyqr. Anything that does not already begin with http:// or https:// has surrounding slashes and spaces stripped and is prefixed with https://www.facebook.com/. Plain strings and {"url": "..."} objects both work, so output from another Actor can usually be piped in unchanged.

What to do when Facebook changes its structure

Nothing, in most cases. The Actor reads Facebook's embedded JSON payloads rather than CSS selectors on rendered markup, so a visual redesign generally leaves it working. Several fields also have a regex fallback path over the raw HTML, so a moved key degrades one field instead of failing the row. The scraper is maintained and the output key names and types stay the same on your end.

⬇️ Input

Three parameters, one of them required. Names, types, defaults and ranges below are copied from the Actor's input schema.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Full Facebook page links or plain usernames, one per line. Bulk lists are supported. Plain strings and {"url": "..."} objects are both accepted.	["https://www.facebook.com/copperkettleyqr", "ChrisBrecheensWritingAboutWriting"]
maxPages	No	integer	Cap on how many pages this single run collects. Minimum 1, maximum 10000, default 10.	50
proxyConfiguration	No	object	Apify Proxy settings. This Actor always runs through Apify RESIDENTIAL proxy — datacenter or custom proxy groups entered here are ignored. On blocked pages it tries up to 3 fresh residential sessions before giving up on that URL. Proxy access must be enabled on your Apify plan.	{"useApifyProxy": true}

Example input

{
  "startUrls": [
    "https://www.facebook.com/copperkettleyqr",
    "https://www.facebook.com/ChrisBrecheensWritingAboutWriting",
    "humansofnewyork"
  ],
  "maxPages": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Common pitfall: maxPages truncates your input list, it does not queue the remainder. The Actor cuts startUrls down to the first maxPages entries before it fetches anything, so pasting 200 Pages while leaving maxPages at its default of 10 scrapes the first 10 and silently discards the other 190. Raise maxPages to match your list. Values outside 1–10000 are clamped to the nearest bound, and a non-numeric value falls back to 10.

⬆️ Output

Every successfully scraped Page is one dataset row with the same 33 top-level keys in the same order, run after run. Values that Facebook does not expose to a logged-out visitor come back as null — or as [] for the list-shaped keys categories, info, websites and instagram — never as a missing key, so downstream code needs no presence check. Export as JSON, CSV or Excel, or read the dataset through the Apify API.

The one exception is a failed page, which is written with three keys only. See the second block below.

Scraped Facebook Page

{
  "facebookUrl": "https://www.facebook.com/copperkettleyqr",
  "categories": ["Restaurant"],
  "category": "Restaurant",
  "info": [
    "Copper Kettle Restaurant. 4,182 likes",
    "1953 Scarth St, Regina, SK, Canada"
  ],
  "likes": 4182,
  "followers": 4310,
  "followings": 128,
  "priceRange": "$$",
  "title": "Copper Kettle Restaurant",
  "pageId": "100063564821907",
  "pageName": "copperkettleyqr",
  "pageUrl": "https://www.facebook.com/copperkettleyqr",
  "intro": "Family-run restaurant in downtown Regina serving pizza, pasta and Greek classics since 1975.",
  "address": "1953 Scarth St, Regina, SK, Canada",
  "addressUrl": "https://www.google.com/maps/place/1953+Scarth+St+Regina",
  "websites": [
    "http://www.copperkettleregina.com",
    "https://www.google.com/maps/place/1953+Scarth+St+Regina",
    "https://www.instagram.com/copperkettleyqr"
  ],
  "website": "copperkettleregina.com",
  "phone": "+1 306-525-3545",
  "email": "info@copperkettleregina.com",
  "instagram": [
    {
      "username": "copperkettleyqr",
      "url": "https://www.instagram.com/copperkettleyqr"
    }
  ],
  "alternativeSocialMedia": "https://www.instagram.com/copperkettleyqr",
  "services": "Dine-in · Takeout · Delivery",
  "businessHours": "Open now",
  "rating": "94% recommend (202 Reviews)",
  "ratingOverall": 94,
  "ratingCount": 202,
  "profilePictureUrl": "https://scontent.xx.fbcdn.net/v/t39.30808-1/436705561807015_n.jpg",
  "coverPhotoUrl": "https://scontent.xx.fbcdn.net/v/t39.30808-6/318204471902238_n.jpg",
  "profilePhoto": "https://www.facebook.com/photo/?fbid=436705561807015",
  "creationDate": "March 04, 2011",
  "adStatus": "This Page is currently running ads.",
  "pageAdLibrary": {
    "isBusinessPageActive": true,
    "id": "100063564821907"
  },
  "success": true
}

Notes on how a few of these are built, because they are derived rather than copied straight through:

• addressUrl is only populated when the Page publishes a real Google Maps link in its intro card. No search URL is ever synthesised — the key is null when there is no genuine link.
• profilePhoto is a facebook.com/photo/?fbid= permalink, derived from the profile photo ID or from the numeric ID embedded in the profile picture filename.
• priceRange is normalised to $ symbols; a Page showing £££ is returned as $$$.
• creationDate is the Page-level creation time only, formatted as March 04, 2011. Recent-post timestamps are deliberately not used as a substitute, so this key is null rather than misleading when Facebook does not expose the real value to a logged-out visitor.
• followers and followings are converted from Facebook's compact form, so 1.2K becomes 1200.
• facebookUrl and pageUrl carry the same value; both are kept so existing field mappings do not have to change.

Rows for pages that could not be scraped

A page that fails every attempt is still pushed, and still charged as row_result. It carries three keys — the other 30 are omitted entirely, not set to null:

{
  "facebookUrl": "https://www.facebook.com/some-removed-page",
  "error": "Failed to scrape page after 4 attempts",
  "success": false
}

Filter these out with success == true before loading the dataset anywhere. If every page in a run fails, the run itself is marked failed with a status message pointing you at the logs — but the rows are already in the dataset.

How does Facebook Pages Scraper compare to other Facebook Page scrapers?

Observed on the Apify Store on 25 July 2026, across the three most established Facebook Page contact Actors: apify/facebook-page-contact-information, powerful_bachelor/Facebook-Page-Contact-Info-Scraper and memo23/facebook-page-contact-detail-scraper.

Feature	Facebook Pages Scraper	The three listings checked
Output keys documented in the README	✅ All 33 keys, with derivation notes	memo23 publishes a 16-key example JSON; the other two do not document their output shape
Input parameter table with types and ranges	✅ Names, types, defaults, min/max	❌ Not documented on any of the three; memo23 shows an example input JSON only
Proxy behaviour stated as implemented	✅ Always residential, input tier ignored, up to 3 fresh sessions	memo23 recommends residential as a best practice; apify and powerful_bachelor do not document proxy behaviour
Business and about metadata beyond contacts	✅ priceRange, businessHours, services, adStatus, pageAdLibrary, creationDate	powerful_bachelor lists check-ins and likes; memo23's example includes rating but not hours, services or ad status
Explicit per-row status flag	✅ success on every row, with the exclusion filter documented	❌ Not documented on any of the three
Login or cookie requirement	✅ None	memo23 documents a Puppeteer mode that requires cookies alongside a cookie-free default

Two honest caveats. memo23's documented output includes a messenger key that this Actor does not return. And apify/facebook-page-contact-information is the most widely used Facebook Page contact Actor on the Store — its README is short because it does not need to sell.

If you are building an AI agent or a RAG pipeline, the output-format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature.

How many pages can you scrape with Facebook Pages Scraper?

maxPages accepts 1 to 10000 and defaults to 10. It is a cap on input URLs processed in this run, applied by truncating your startUrls list before any fetching starts — not a pagination depth, and not a row budget applied at the end. Because the Actor produces exactly one row per processed URL, it is also, in practice, the ceiling on your row count.

There is no pagination to configure. A Facebook Page is a single fetch, not a paged result set, so there is no "next page" concept in this Actor at all. Pages are fetched sequentially — one at a time, with a two-second pause between them, and each request allowed thirty seconds — which is why very large lists are better split across scheduled runs than pushed through in one.

If you need more than 10,000 Pages, split the list into batches and run them separately, or put the batches on an Apify schedule.

Integrate Facebook Pages Scraper and automate your workflow

Facebook Pages Scraper works with any language or tool that can send an HTTP request, plus everything that can consume an Apify dataset.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/facebook-pages-scraper").call(run_input={
    "startUrls": ["https://www.facebook.com/copperkettleyqr", "humansofnewyork"],
    "maxPages": 50,
    "proxyConfiguration": {"useApifyProxy": True},
})

for page in client.dataset(run["defaultDatasetId"]).iterate_items():
    if page.get("success"):
        print(page["title"], page["email"], page["phone"], page["website"])

Works in Python, Node.js, Go, Ruby, cURL. Keep the success check: it is what separates real Page rows from the three-key failure rows.

Automation platforms (n8n, Make, LangChain)

In n8n, use the Apify node — or an HTTP Request node pointed at the Actor's run endpoint with your Apify token — and pass the same input JSON shown above; a Filter node on success then keeps failed rows out of the downstream branch. In Make, the Apify module supports run-and-wait, so a weekly Page sweep can map email, phone and address straight into a Google Sheets, Airtable or HubSpot step. In LangChain or any other agent framework, wrap the Apify run endpoint as a tool: the response is already typed JSON, so there is no output parser to write. Apify schedules and webhooks handle recurrence and completion callbacks without any code on your side.

Is it legal to scrape Facebook Pages?

Scraping publicly visible Page data is broadly treated as permissible where no authentication is bypassed, and this Actor reads only what an anonymous visitor sees — no account, no cookie, no session.

But be clear about what comes back. For a small business, a creator or a sole trader, the Page email, phone number and address in email, phone and address are frequently personal data under the GDPR, the UK GDPR and the CCPA. Public availability is not by itself a lawful basis. If you store, enrich or use these fields for outreach, you need one — and in the EU and UK a notification obligation typically follows when you collect personal data from a source other than the individual.

Facebook's own terms of service also apply to automated collection, independently of data-protection law.

Consult legal counsel for commercial use cases involving bulk personal data.

❓ Frequently asked questions

Does Facebook Pages Scraper work without a Facebook account?

Yes. No Facebook account, login, cookie or session is used. The Actor fetches the logged-out public version of each Page. The only credential involved is your Apify token, and the only account requirement is that residential proxy access is enabled on your Apify plan.

How fresh is the scraped Page data?

It is fetched live on every run — there is no cache layer and no stored snapshot. Each URL is requested at the moment the run reaches it, so a value that changed on Facebook an hour ago is the value you get. For change tracking, put the same startUrls on an Apify schedule and diff by pageId.

What happens when a Page is removed, renamed or unavailable?

You get a row, not a gap. The Actor treats a redirect to a login URL or an HTTP 400, 401 or 403 as a block and retries through fresh residential sessions; a page that is genuinely gone will not recover, and after four attempts it is written as {"facebookUrl": ..., "error": "Failed to scrape page after 4 attempts", "success": false}. A renamed Page is a different case: Facebook usually redirects the old vanity URL to the new one, so the row succeeds but pageName reflects the new handle. Join on pageId, which is stable across renames, rather than on the URL.

What happens when a username resolves to nothing?

The same failure row. A bare username such as notarealpage is normalised to https://www.facebook.com/notarealpage and fetched exactly like any other URL — the Actor does not pre-validate that it exists. Facebook's response for a non-existent handle yields no usable payload, so you receive a success: false row with the error string. That row is charged as row_result like any other, so it is worth sanity-checking handle lists before large runs.

Can I scrape private, login-gated or hidden Page details?

No. Only what is publicly visible without logging in is returned. Contact details a Page owner has chosen not to display, anything behind Facebook's login wall, and personal-profile content that is not a Page are all out of scope. If a Page hides its email, email comes back null — the Actor does not guess or infer one.

Do I pay for pages that fail?

Yes, and it is stated plainly rather than hidden: every row pushed to the dataset is charged under the row_result event, including the three-key failure rows. There are no uncharged accounting rows. Filter with success == true when you read the dataset, and keep maxPages aligned with a list you have already checked.

Does Facebook Pages Scraper work for AI agent workflows and LLM pipelines?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n or a hand-written tool definition can invoke it and receive typed JSON with no parsing step. Every value is a primitive, an array or a plain nested object — pass a row straight into an LLM context window, index it into a vector store, or hand it to an agent tool.

How does Facebook Pages Scraper handle Facebook's anti-bot system?

Facebook's main defences against logged-out scraping are IP reputation, login-wall redirects and CAPTCHA interstitials. The Actor answers the first with Apify residential egress on every request, and sends a full desktop Chrome header set — Accept, Accept-Language, Sec-CH-UA client hints and Sec-Fetch headers — rather than a default HTTP client signature. It detects a block when the final response URL contains login or the status is 400, 401 or 403, and treats 429, blocked, rate limit, forbidden, 403, 401, login and captcha in an error message as retryable. On a block it rotates to a fresh residential session and retries, up to three rotations per URL — four attempts in total, with a two-second pause between them. Non-block errors are not retried. The retry counter resets for each new URL.

How does Facebook Pages Scraper compare to other Facebook Page scrapers?

Checked on the Apify Store on 25 July 2026: apify/facebook-page-contact-information is the most widely used Facebook Page contact Actor and documents address, email and phone extraction plus Apify API and integration usage, but does not publish an input parameter table or an output field list. powerful_bachelor/Facebook-Page-Contact-Info-Scraper documents addresses, emails, likes, website links, phone numbers and a check-ins tally as a feature list, with no input or output schema documented. memo23/facebook-page-contact-detail-scraper is the most technically documented of the three — it describes a dual Cheerio/Puppeteer crawler, accepts URLs, plain strings and request objects, and publishes a 16-key example output including a messenger key this Actor does not return. What this Actor documents that none of the three do: the full 33-key output shape, the input schema with types and ranges, the always-residential proxy override, and a per-row success flag with the filter that excludes failed rows.

Does Facebook Pages Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with the same key names on every run — no HTML, no selectors, no parsing step. title, intro, categories and services chunk cleanly for RAG indexing; likes, followers, followings, ratingOverall and ratingCount are the most structurally consistent numeric fields across records.

Can I use Facebook Pages Scraper without managing proxies?

Yes. You never create a proxy account, pick a group or rotate an IP — the Actor builds its own Apify residential configuration and handles session rotation on blocks. The one thing you do control is entitlement: residential proxy access has to be enabled on your Apify plan, or the run fails at startup with a status message saying so.

What happens when Facebook changes its structure or blocks the scraper?

The scraper is maintained. Because it reads Facebook's embedded JSON payloads rather than rendered markup, a front-end redesign generally does not affect it, and several fields have a secondary regex path over the raw HTML so a moved key degrades one field instead of failing the row. Your field names and types do not change on your end.

🔗 Related scrapers

Scraper Name	What it extracts
Facebook Page Engagement Analytics Scraper	Post-level engagement analytics for Facebook Pages
Facebook Groups Search Scraper With Group Details Rules	Group discovery with group metadata and rules
Facebook Group Active Members Extractor	Active member records from Facebook groups
Facebook Search Scraper WhatsApp Contact Leads	Search results enriched with WhatsApp contact leads
Facebook Videos Scraper Commenters Reactors Sharers	Commenters, reactors and sharers behind Facebook videos

💬 Your feedback

Found a bug, or need a Page field that Facebook exposes publicly but this Actor does not yet return? Open an issue on the Actor's Issues tab and it will be looked at. Reports that include the exact startUrls value and the Page you were targeting are the fastest to reproduce and fix.