Facebook Page Scraper — Contact, Category & Likes

Bulk contact extraction from public Facebook business Pages. One row per Page, carrying page_id, name, category, phone, email, website (and every extra website the Page lists), address, likes, talking_about, were_here, bio, profile_url and profile_pic_url. Feed it Page handles, full Facebook Page URLs, numeric Page ids — or upload a file / Google Sheet of Page URLs.

No login. No cookies. No Facebook account. No CAPTCHA solving.

86% of small-business Pages returned an e-mail address and 90.7% returned a phone or an e-mail — measured on 86 live Pages on 2026-08-12, not estimated. On global mega-brand Pages the same fields are 8.3% and 37.5%; both tables are published below, because which one applies to you decides whether you should buy this at all.

$0.0036 per Page returned — $3.60 per 1,000, no actor-start fee.

{
  "pages": ["nike", "https://www.facebook.com/nasa", "starbucks"]
}

Click Try for free and hit Start — that is the input this Actor ships with. It returned 3 rows in 8 seconds on the last measured run.

How to use it

1. Click Try for free, then Start — the prefilled input returns rows immediately.
2. Replace the three demo Pages with your own list: a bare handle (nike), a full URL (https://www.facebook.com/nasa), or a numeric Page id — mixed together is fine.
3. Bulk instead: open 📄 Page URL list and paste hundreds of URLs, upload a .txt/.csv, or link a Google Sheet.
4. Watch the log. Every Page that could not be read is named, and the run prints its own totals at the end.
5. Export the dataset as JSON, CSV, Excel or HTML, or pull it from the API.

The wedge: e-mail addresses on small-business Pages

Most Facebook Page scrapers sell you followers and engagement counts. The field a lead-gen buyer actually pays for is a contactable business e-mail, and Facebook's public About surface publishes one far more often than people expect — on small businesses.

Measured on a random 100-handle sample of small-business Pages (see the sample description below):

• 86.0% carried an e-mail address (74 of 86 rows)
• 52.3% carried a phone number, 55.8% a full street address, 94.2% a website
• 34.9% carried all four — phone and e-mail and address and website in the same row
• 90.7% carried a phone or an e-mail, i.e. something you can actually contact

That is the whole product. The engagement counts come along for free.

Read this before you buy rows

1. This is a small-business tool, not a big-brand tool. On 24 global brand Pages (Nike, Pepsi, Netflix, IKEA…) e-mail fill was 8.3% and address fill 4.2%. Mega-brands route you to a support site instead of publishing a mailbox. Both fill tables are below — plan against the one that matches your list.
2. Some Pages are login-walled by Facebook and cannot be read by anyone logged out. In the 100-handle sample, 14 of 100 handles returned Facebook's login redirect instead of the About surface, and retrying 6 of those on RESIDENTIAL proxies cleared 0 of 6 — for those Pages it is not an IP problem and not fixable without logging in, which this Actor does not do. You are not billed for them. Separately, Facebook does sometimes wall the datacenter pool itself for a stretch; that one is an IP problem, and the Actor now clears it itself: any Page the datacenter rung cannot read is automatically retried through RESIDENTIAL (see the transport ladder).
3. talking_about and were_here are not universal. They came back on 76.7% and 33.7% of rows respectively — Facebook only renders "talking about this" and "were here" on Pages that have them. A null means Facebook published nothing, not that the scrape failed.
4. The category is the Page's own self-declared category, one string from Facebook's list ("Escape Game Room", "Automotive Parts Store"). 56 distinct categories appeared across the 82 Sample A rows that carried one. It is not a normalised taxonomy and it is not NAICS.
5. This Actor returns Page profile data only — no posts, no reviews, no ads, no follower lists. That is deliberate; see the routing table below.

What you get — one row per Facebook Page

Group	Fields
Identity	page_id (numeric, stable, the dedupe key), page_slug, name, profile_url
Contact	phone, email, address, website, websites (every URL the Page lists)
Classification	category, categories
Engagement	likes, talking_about, were_here
Copy & media	bio, profile_pic_url
Provenance	scraped_at (ISO-8601 UTC)

likes, talking_about and were_here are plain integers. Every other field is a string, websites/categories are arrays, and anything Facebook did not publish is null (or [] for the arrays) — never an empty string, never a zero standing in for "missing".

Field fill — measured on two real samples

Both runs used the shipped defaults: Apify datacenter proxy, concurrency 5, 400 ms pacing. Measured 2026-08-12, through Apify proxies.

Sample A — 86 small-business Pages

100 Facebook Page handles drawn at random from the ~13,100 distinct facebook.com/<handle> links in our own lead corpus — crowdfunding creator profiles plus pre-order and independent e-commerce stores: independent studios, publishers, shops, trades and local retailers across the US, EU and UK. 86 returned rows, 14 were login-walled, 0 returned HTTP 404. Total wall time 283 s.

Field	Fill	Rows
page_slug, name, profile_url, profile_pic_url, scraped_at	100.0%	86
page_id	98.8%	85
likes	98.8%	85
bio	96.5%	83
category / categories	95.3%	82
website / websites	94.2%	81
email	86.0%	74
talking_about	76.7%	66
address	55.8%	48
phone	52.3%	45
were_here	33.7%	29

Sample B — 24 global brand Pages

25 well-known brand handles (nike, nasa, starbucks, cocacola, pepsi, adidas, samsung, spotify, netflix, airbnb, McDonalds, Walmart, target, IKEAusa, sephora, homedepot, lowes, Costco, delta, SouthwestAir, marriott, hiltonhotels, chipotle, Dominos, subway). 24 returned rows, 1 was login-walled. Total wall time 75 s.

Field	Fill	Rows
page_id, name, category	100.0%	24
likes, talking_about, bio, website, profile_pic_url	95.8%	23
phone	29.2%	7
were_here	29.2%	7
email	8.3%	2
address	4.2%	1

The headline that could mislead you: the 86% e-mail rate is a small-business number. Point this Actor at the Fortune 500 and you will get names, categories, likes and websites — and almost no contact data, because those Pages publish none.

Sample rows

A fully-filled small-business row, and a thin mega-brand row, both from the runs above:

{
  "page_slug": "AxePalace",
  "page_id": "100064803457684",
  "name": "The Axe Palace | Walpole MA",
  "profile_url": "https://www.facebook.com/AxePalace",

  "category": "Musical Instrument Store",
  "categories": ["Musical Instrument Store"],

  "likes": 42292,
  "talking_about": 220,
  "were_here": 821,

  "bio": "Elite Gear, Top Notch Service & Great Deals! If you aren't familiar with what kinds of guitars, amps and accessories we...",

  "phone": "(508) 921-9973",
  "email": "sales@axepalace.com",
  "website": "http://axepalace.com/",
  "websites": [
    "http://axepalace.com/",
    "https://discord.gg/pJprtC5gSq",
    "https://axepalace.nl/"
  ],
  "address": "3 Glenwood Ave, Walpole, MA, United States, 02081",

  "profile_pic_url": "https://scontent-iad3-1.xx.fbcdn.net/v/t39.30808-1/275830594_...jpg",
  "scraped_at": "2026-08-13T02:06:26.578Z"
}

{
  "page_slug": "pepsi",
  "page_id": "100068774162227",
  "name": "Pepsi",
  "profile_url": "https://www.facebook.com/pepsi",

  "category": "Product/service",
  "categories": ["Product/service"],

  "likes": 35752931,
  "talking_about": 1170,
  "were_here": null,

  "bio": "Welcome To Pepsi Global!",

  "phone": null,
  "email": null,
  "website": "http://www.pepsi.com/",
  "websites": ["http://www.pepsi.com/"],
  "address": null,

  "profile_pic_url": "https://scontent-dfw6-1.xx.fbcdn.net/v/t39.30808-1/361089957_...jpg",
  "scraped_at": "2026-08-13T02:18:51.095Z"
}

Things people misread in these rows:

• bio is truncated by Facebook, not by us. The trailing ... on the Axe Palace row is exactly what Facebook's public description carries.
• address is one string, not parsed components. Facebook renders it as a single line; splitting it into street/city/postcode would mean guessing, so we ship what the source published.
• websites is a superset of website. website is the first entry; the array catches the Linktree, Discord and country-domain links Pages pile into that section. 11 of 86 rows in Sample A carried more than one.
• phone is a formatted string, in whatever format the Page owner typed — (508) 921-9973, +31 20 261 6433, +351 272 011 191. It is not normalised to E.164.

Input

Fields appear here in the same order as the Console.

Field	Type	Default	What it does
pages	array of strings	["nike", "https://www.facebook.com/nasa", "starbucks"] (prefill)	One Page per line: bare handle, full Facebook URL, facebook.com/handle, or a numeric Page id / profile.php?id=… URL. Also your cost ceiling — you are billed per Page returned.
startUrls	request list	[]	The bulk path: paste many URLs, upload a .txt/.csv, or link a Google Sheet. Must contain full Facebook URLs. Merged with pages and de-duplicated. Reading the list is free.
proxyConfiguration	object	Apify Proxy (datacenter)	Leave it. Datacenter is the cheap first rung, and walled Pages are automatically retried through Residential (capped) — see the transport ladder.
requestConcurrency	integer	5	Pages fetched at once, 1–10. 5 measured 100 handles in 283 s.
requestDelayMs	integer	400	Per-worker pacing. The measured 86/100 success rate was taken at 400 ms.

The three ways to name a Page

{ "pages": ["nike", "facebook.com/nasa", "https://www.facebook.com/starbucks"] }

{ "pages": ["100044541544829", "https://www.facebook.com/profile.php?id=100064326836270"] }

A numeric Page id cannot be fetched directly — Facebook serves facebook.com/<id>/about to logged-out clients behind a login redirect. The Actor resolves the id to the Page's handle first (one extra request, never billed) and then reads the Page normally. Handles are the faster path when you have them.

{
  "pages": [],
  "startUrls": [
    { "url": "https://www.facebook.com/AxePalace" },
    { "requestsFromUrl": "https://example.com/my-page-urls.txt" }
  ]
}

Pricing

$0.0036 per Facebook Page returned — $3.60 per 1,000 Pages. No actor-start fee, no monthly platform fee from this Actor. Charged on the page-scraped event.

What is not billed:

• A Page that Facebook login-walls, 404s, or that fails after retries. 14 of the 100 handles in Sample A produced no row and no charge.
• The extra request spent resolving a numeric Page id to a handle.
• Downloading your startUrls file or Google Sheet.
• The same Page twice. De-duplication happens on the numeric page_id before anything is written, so listing nike, facebook.com/nike and 100044541544829 in one run bills you once.

Rows are charged as they are pushed (Actor.pushData(items, 'page-scraped')), so if you hit a budget cap you get whole rows and stop — never a half-billed dataset.

Run	Pages returned	Cost
The prefilled demo run	3	$0.011
A prospect list	100	$0.36
A territory	1,000	$3.60
A full database build	10,000	$36.00

Your cost dial is the length of your input list — there is no other cap, and no way to be charged for a Page you did not ask for.

Honest limits

• 8.3% e-mail fill on mega-brand Pages. If your list is global brands, this Actor is a name/category/likes/website product and nothing more. Buy it for small businesses, or do not buy it.
• 14 of 100 sampled Pages were login-walled and returned nothing. Those handles serve HTTP 200 and a redirect to /login/?next=… on datacenter and residential exits alike (0 of 6 cleared on residential). There is no workaround that does not involve logging in, and this Actor does not log in.
• The datacenter success rate moves between runs. 24/25 on the Sample-B brands on 2026-08-12; 11/25 on the same 25 handles on 2026-08-13, when Facebook was walling the datacenter pool (single-attempt 3/15 datacenter vs 10/10 residential that hour). The Actor now absorbs those windows itself: a Page the datacenter rung cannot read is automatically retried through RESIDENTIAL, capped at max(3, 20% of your list) per run. On a very bad datacenter day a very large run can still exhaust the cap and come back short — the log tells you (residential fallback used for N of M pages), you are never billed for a Page that returned nothing, and re-running the misses on Residential clears them.
• No rating, no opening hours, no price range, no services, no social handles. Facebook does publish some of those on the same About surface — a census of 7 Pages found ratings on 6, screenname (TikTok/Instagram links) on 5, business_hours, business_price and business_services on 2 each. This Actor does not parse them today. If you need opening hours and popular-times traffic, saswave/facebook-company-page-scraper returns those; if you need followers, page rating, creation date or ad-library id, use apify/facebook-pages-scraper.
• No posts, no reviews, no comments, no ad creatives. Those load from separate signed endpoints — a different job for a different Actor. For ads, use our Meta Ad Library Scraper.
• address is a single unparsed string and 55.8% filled on small businesses, 4.2% on brands.
• phone is not normalised. You get whatever the owner typed.
• Business Pages only. Personal profiles are out of scope and are not a supported input.
• Dedupe is within a run. Two separate runs over overlapping lists will bill you for the overlap; de-duplicate on page_id on your side, or keep your lists disjoint.

How it works, and the transport ladder

Facebook still serves a full server-rendered HTML page — with an embedded JSON blob — to a plain HTTP client on the public /<handle>/about surface. No login, no Chromium, no GraphQL token mint:

• <meta og:title> → the Page name
• <meta og:description> → likes, talking-about, were-here and the bio
• "pageID" / "userID" / "delegate_page" → the numeric Page id (used as the dedupe key; the logged-out viewer id "0" is explicitly rejected)
• "profile_field_sections" → category, phone, e-mail, website and address, read with a balanced-bracket JSON slice rather than a regex over the whole document

That is why it runs at 512 MB with no browser.

Measured through Apify, on Apify proxies:

Rung	Result
Apify datacenter, fresh session per call, 20 varied brand Pages (build-time)	16/20 first attempt, 19/20 with one retry
Apify datacenter, 100 random small-business handles, 2026-08-12	86/100 rows, 0 × HTTP 404, 14 login-walled
Apify datacenter, 25 global brand handles, 2026-08-12	24/25 rows, 1 login-walled
Apify RESIDENTIAL, retrying 6 of the Sample-A login-walled handles	0/6 — those Pages are walled for every logged-out client
Apify datacenter, 15 brand handles, single attempt, 2026-08-13	3/15 — the pool itself was being walled that hour
Apify RESIDENTIAL, the same brand handles, single attempt, 2026-08-13	10/10
Apify datacenter, the 25 Sample-B brand handles re-run, 2026-08-13	11/25 rows in 95 s
Apify RESIDENTIAL, pinned session (the fallback rung's exact transport), 3 fresh sessions, 2026-08-15	3/3 usable
Shipped ladder (datacenter → capped RESIDENTIAL fallback), the 3-Page demo input, 10 consecutive platform runs, 2026-08-15	10/10 runs × 3/3 rows, 5–82 s per run
Both-rungs-failed proof, platform run with one age-gated Page mixed in, 2026-08-15	walled Page retried on RESIDENTIAL, still unreadable → skipped and unbilled; the other 2 rows delivered and charged 2

Throughput at the default concurrency of 5: 100 handles in 283 seconds, about 18 rows a minute.

The datacenter rate is not a constant, and the Actor no longer asks you to care. Facebook throttles a datacenter pool that has been busy: the same 25 brand handles that returned 24/25 one night came back 11/25 the next, and single-attempt success on the pool dropped to 3/15 while RESIDENTIAL returned 10/10 on those same handles. Since 2026-08-15 the ladder climbs itself:

1. Datacenter first — four attempts, a fresh session each time. This cheap rung carries most runs whole.
2. RESIDENTIAL fallback, automatically — any Page still walled or empty after the datacenter attempts is retried through Apify RESIDENTIAL with a pinned session (one sticky residential IP per Page). Measured on the pinned-session path: 3/3 usable fetches on fresh sessions, and 10/10 consecutive platform runs of the demo input returned full rows on the shipped ladder (2026-08-15).
3. The fallback is capped at max(3, 20% of your list) of Pages per run, so the expensive rung stays a repair kit, not the transport. The economics of the cap: a residential /about fetch costs roughly $0.0022/Page in proxy transfer against ~$0.00288/Page net revenue — thin but positive per Page, and the cap bounds the worst case on a bad datacenter day.
4. Every run logs the fallback count — residential fallback used for N of M pages — so you can see exactly which rung carried your rows.

A Page that fails both rungs produces no row and no charge. If a very large run exhausts the cap during a walled window, re-run the misses (or set Proxy to Residential for that run).

Uniqueness and de-duplication

Facebook Pages have one stable numeric page_id, and one Page can be reached by several handles and by its id. The Actor de-duplicates on page_id before the row is written and billed.

Measured on Sample A: 86 rows, 86 distinct page_id values, 0 duplicates — that walk was 100 contiguous handles from one list, not a sparse sample.

Across runs there is no memory: run the same list twice and you pay twice. Keep your input lists disjoint, or de-duplicate on page_id downstream.

When a run comes back short

• Zero rows stops the run cleanly, and bills nothing. If nothing was scraped, the Actor finishes with a status message carrying the counts — No Pages scraped — … (N not found, M blocked/empty). Nothing billed. — and an empty dataset. Zero rows on Facebook is a transport condition (a walled window, or bad handles), not a broken scraper, so re-running usually fixes it; set Proxy to Residential if it repeats.
• Empty input runs the documented sample. If you start the Actor with no Pages at all, it scrapes the three sample Pages (nike, nasa, starbucks) and warns twice in the log that those rows are the sample, not your data — so a demo click never errors out. Those 3 sample rows are billed like any other row (about $0.01); set Pages to scrape your own list.
• A bad handle never kills the run. A 404 is logged as page not found; a login wall is logged as no page data after retries; both are skipped, both are unbilled, and the rest of the list continues.
• An unresolvable numeric id is named in the log rather than silently dropped.
• Every run prints its own totals: how many Pages were queued, how many duplicate inputs were skipped, how many were not found, how many failed, and how many rows were pushed. If a number looks wrong, the log already told you which handle caused it.

Who buys this

• Agencies selling websites and marketing to local businesses — the 52.3% with a phone and the 5.8% of Sample A rows with no website at all are two ready-made call lists.
• SMB SaaS doing outbound (POS, booking, scheduling, payments) — email at 86% plus category is a segmented cold-email list; "Escape Game Room" and "Automotive Parts Store" are the ICP filters.
• CRM and lead-database enrichment — feed a list of Facebook URLs you already hold and get back phone, e-mail, address and category to fill the gaps.
• Local-services marketplaces recruiting supply — address plus category plus were_here finds real premises with real foot traffic.
• Competitive and market analysts — likes and talking_about on a schedule, tracked per page_id, is a cheap share-of-attention series.

Which Facebook Page Actor should you use?

Rates verified against the live Apify Store on 2026-08-12; per-result rates are the Free-plan tier.

Actor	What it gives you	Rate	Use it instead when
This one	Contact + category + engagement, bulk	$0.0036/Page, no start fee	You have a list of business Pages and want contact data cheaply
apify/facebook-page-contact-information	Address, e-mail, phone only	$0.013/result + $0.001 start	You want the Apify namespace and nothing but the three contact fields
apify/facebook-pages-scraper	Followers, page rating, creation date, ad-library id, profiles	$0.012/result	You need followers, ratings, creation date or non-Page profiles
saswave/facebook-company-page-scraper	Opening hours, popular-times traffic, price range	$0.004/result + $0.00005 start	You need opening hours or footfall-by-hour
cleansyntax/facebook-pages-scraper	General page fields	$0.006/result	—
igview-owner/facebook-page-details-scraper	Social links, hours, verified badge	$0.02/result + $0.02 start (Free tier)	You need Instagram/LinkedIn/X handles off the Page
Our Meta Ad Library Scraper	The ads a Page is running	see its page	You want ad creatives and spend signals, not Page contact data

The one-liner: this Actor is the cheapest way to turn a list of business Pages into contactable rows. If you need followers, ratings or opening hours, one of the others above is the right buy and this one is not.

Using it from the API

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('ScrapersDelight/facebook-page-scraper').call({
    pages: ['nike', 'https://www.facebook.com/nasa', 'starbucks'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("ScrapersDelight/facebook-page-scraper").call(run_input={
    "pages": ["nike", "https://www.facebook.com/nasa", "starbucks"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Results export as JSON, CSV, Excel, HTML or RSS, and the Actor connects to Make, Zapier, Google Sheets, Google Drive, Slack, Airbyte, GitHub and webhooks through Apify integrations. Schedule it to re-read the same Page list on a cadence.

FAQ

How do I scrape a Facebook Page? Paste the Page handle (nike) or its URL into the Pages field and hit Start. The prefilled demo works with zero edits and returned 3 rows in 8 seconds.

Do I need a Facebook account, cookies or a login? No. It reads the public /about surface as a logged-out visitor. No account, no cookies, no session token, no CAPTCHA-solving service.

How much does it cost? $0.0036 per Page returned — $3.60 per 1,000, with no actor-start fee. 100 Pages is $0.36.

Do I get charged for Pages that return nothing? No. Login-walled, missing and failed Pages produce no row and no charge — that was 14 of 100 handles in the measured sample.

Two runs over the same list — will I get duplicates? Within one run, no: de-duplication happens on the numeric page_id before anything is written or billed (86 rows, 86 distinct ids in the measured walk). Across runs, yes — there is no cross-run memory.

Can I upload a list of Page URLs? Yes. 📄 Page URL list takes a bulk paste, a .txt/.csv upload or a Google Sheet link. Entries must be full Facebook URLs; a bare handle in a file is ignored.

Do I need residential proxies? No — the Actor manages the ladder itself. It runs on datacenter (86/100 and 24/25 in the measured samples) and automatically retries any walled Page through RESIDENTIAL, capped at max(3, 20% of your list) per run; the log prints residential fallback used for N of M pages every run. Pages that Facebook itself login-walls (0 of 6 cleared on residential) stay unreadable on every rung and are never billed. Switch Proxy to Residential yourself only if a huge run during a walled window exhausts the cap.

Does it return posts, reviews or ads? No, and that is deliberate — those load from separate signed endpoints and belong in their own Actors. For ads, use our Meta Ad Library Scraper.

Does it return followers, page rating or opening hours? No. apify/facebook-pages-scraper returns followers and rating; saswave/facebook-company-page-scraper returns opening hours. See the routing table above.

Why is email null on a Page I know has an e-mail? Because Facebook did not publish it on the public About surface for that Page. Fill was 86.0% on small businesses and 8.3% on mega-brands — a null is the source's silence, not a parsing failure.

What if a Page does not exist or was renamed? It is detected, named in the log, skipped and not billed. The run continues.

Will a run ever finish with zero rows? Yes, if Facebook served nothing usable for any handle you gave it — and you are charged nothing for it. The run's status message carries the not-found and blocked counts, and every skipped handle is named in the log, so an empty dataset always comes with the reason attached.

Can I use a numeric Page id? Yes. Facebook will not serve facebook.com/<id>/about to a logged-out client, so the Actor resolves the id to the Page's handle first, at the cost of one extra unbilled request.

Something looks wrong — how do I debug it? Read the run log. Every skipped handle is named with the reason, and the run prints queued / duplicate / not-found / failed / pushed totals at the end.

Legal and fair use

This Actor reads publicly visible Facebook business Page pages as a logged-out visitor. It does not log in, does not use or store cookies or credentials, does not solve CAPTCHAs, and collects no data behind any authentication. Pages that Facebook chooses to place behind a login are reported as unreadable and skipped — never circumvented.

Scope is business and brand Pages, not personal profiles. Page data can still constitute personal data (an owner's phone number or mailbox on a sole-trader Page), so you are responsible for complying with Facebook's Terms of Service and with the law that applies to how you store and use the data — GDPR, CCPA, CAN-SPAM, PECR and equivalent regimes for any outreach you do with it.

Facebook® and Meta® are trademarks of Meta Platforms, Inc. This Actor is not affiliated with, endorsed by, or sponsored by Meta.

Feedback

Found a missing field or want a new filter? Open an issue on the Issues tab.