🆔 Facebook URL → ID Plus

Facebook ID Extractor — Resolve Pages, Groups and Posts to IDs

Facebook URL → ID Plus turns any public Facebook link — a page, a group, a post, a video, a reel, or a profile — into a stable numeric Facebook ID, plus the canonical URL, name, category, verified status, follower/like counts, member count, ad-library ID, and post author, as typed JSON columns. It also runs in reverse: feed it a numeric ID and get the canonical URL and name back. Unlike scraping frameworks that hand you raw HTML to parse, this Facebook ID extractor returns clean typed fields — ready for a CRM, an ad account mapping, a database, or an LLM context window without any parsing step. The guide below covers every input and output field plus three deployment patterns teams actually run this on.

🧭 What Does Facebook URL → ID Plus Do?

Facebook URL → ID Plus is a Facebook ID lookup tool: it fetches a public Facebook URL, detects whether it points at a page, profile, group, or post, and pulls the underlying numeric ID straight out of the page's embedded Relay/Comet JSON — not a guess based on the first ID-looking string it finds. No Facebook account, login, or API access token is required; every fetch is unauthenticated and reads only what a logged-out visitor can see.

• 🔗 Resolves pages and profiles — vanity URLs, profile.php?id=, @handle, bare vanity strings — to a numeric facebookId, name, username, category, verified flag, follower/like counts, and Ad Library ID
• 👥 Resolves groups — /groups/... URLs — to a numeric group ID, name, member count, and the viewer's join state
• 📝 Resolves posts, videos, reels, and watch links to the numeric story ID and preserves the pfbid... permalink token separately as postId, plus the post's author name and ID
• 🔁 Runs in reverse — a bare numeric ID resolves back to its canonical URL and name (toggle: reverseMode)
• 🧩 Accepts a broad set of URL shapes: fb.me short links, m.facebook.com / web.facebook.com mobile hosts, l.facebook.com/l.php?u= redirect wrappers, permalink.php, story.php, and story_fbid= query links
• ⛔ Never fabricates an ID — a link that doesn't resolve to a genuine numeric ID is skipped, not pushed, and not charged

⚡ Features & Capabilities

Facebook URL → ID Plus is built around one job — accurate ID resolution — done across every entity type Facebook's front end exposes, with an honest, uncharged failure path.

Core features

• Multi-entity resolution in one Actor: page, profile, group, and post all go through the same run, auto-detected per URL by detect_url_type() — no separate Actor per entity type
• Typed output, not raw JSON: every row carries the same 20 columns (facebookUrl, facebookId, resolved, type, entityName, username, canonicalUrl, category, isVerified, followerCount, likeCount, memberCount, joinState, adLibraryId, profilePictureUrl, authorName, authorId, createdAt, postId, scrapedAt) — populated where the entity type has that field, null where it doesn't
• Richest-object selection, not first-match: for pages the extractor scores every user/profile object found in the page's script tags and keeps the one with a profile picture and the most populated keys — not the first ID-shaped object encountered. Groups use the same approach, keeping the object with the most keys among candidates that carry a numeric id
• pfbid token preserved, not discarded: a post URL's pfbid... permalink token is kept as postId alongside the resolved numeric facebookId (the actual story ID) — most tools return one or the other, not both
• Ad Library ID extraction: adLibraryId is pulled from the page's pageAdLibrary object when present, for mapping a Page directly to its Meta Ad Library listing
• Optional raw payload: set includeRawJson to attach the underlying extractor object as a raw field, for cases where the typed columns aren't enough

How Facebook URL → ID Plus compares to other Facebook scrapers

Feature	Facebook URL → ID Plus	apify/facebook-url-to-id	scraper-engine/facebook-url-to-id
Output format	Typed flat columns, fixed schema	Nested {page/group/video_...} object per URL, shape varies by entity (per their own listing)	Nested page_data / group_data / post_data objects with embedded user, node, openGraph blocks
Entity coverage	page, profile, group, post (incl. video/reel/watch)	Pages, posts, videos, groups; "for profiles only ID might be available" (their listing)	Page, group, post, video, profile
Reverse lookup (ID → URL)	✅ Yes, dedicated reverseMode toggle	❌ Not documented	❌ Not documented
Uncharged failure path	✅ Unresolved and filtered-out rows are never pushed or charged	Not documented	Not documented
pfbid token preserved separately from numeric ID	✅ postId field	❌ Not documented	Partial — token appears nested inside post_data, not as a distinct top-level field
Ad Library ID field	✅ adLibraryId	Not documented as a distinct field	Not documented as a distinct field
Pricing model (as observed on the Apify Store, 2026-07-26)	Pay per resolved row	Free	Flat price per month

If your use case is feeding structured data to an LLM or a CRM sync job, the "output format" row is the decision-maker: a fixed, flat schema means your parsing code doesn't branch on entity type, and a nested per-entity object does.

When another tool might suit you better

If the goal is scraping full ad creative, spend, and targeting data from Meta's Ad Library rather than just mapping a Page to its Ad Library ID, a dedicated Ad Library scraper — such as scrapeio's Meta Ad Scraper (as observed on the Apify Store, 2026-07-26) — is the better fit; it returns ad copy, timing, and distribution fields this Actor does not attempt to extract. Likewise, if the goal is bulk post content (text, comments, engagement) rather than ID resolution, a dedicated Facebook Posts scraper is a better starting point — this Actor deliberately stops at the ID and the metadata visible on the entity's own landing page.

Facebook URL → ID Plus within the Scrapio data stack

Facebook URL → ID Plus covers ID resolution across pages, profiles, groups, and posts. For ongoing post content and engagement metrics from a Facebook Page, use Facebook Page Posts & Comments Scraper. For group-level post activity, use Facebook Group Posts & Engagement Scraper. For keyword-driven post discovery with AI enrichment, use Facebook Posts Search Scraper With AI Enrichment.

Why do developers and data teams scrape Facebook?

🏢 CRM and ad-ops teams

Sales and ad-ops teams paste a list of prospect or client Page URLs into startUrls and get back each Page's stable facebookId and adLibraryId to key into a CRM or an ads dashboard — vanity URLs and usernames change, but the numeric ID does not, so it's the field that should actually be stored as the join key.

📊 AI training data and RAG indexing

entityName, category, and username are the high-signal text fields for RAG enrichment — a short, structured description of what an entity is, useful for grounding an agent that needs to answer "what is this Facebook Page/Group about" without fetching the live page. For training data, type, isVerified, and the count fields (followerCount, likeCount, memberCount) are the most consistently structured across records — every row returns them as typed primitives (string, boolean, integer, or null), so no string-to-number parsing is needed downstream.

📱 Competitive and market intelligence

Track followerCount and likeCount for a set of competitor Pages over successive scheduled runs to chart audience growth, and adLibraryId presence/absence to spot which competitors have started or stopped running ads through Meta's Ad Library.

🔬 Research and academic use

Researchers building datasets of public Facebook entities — for social-network structure studies, misinformation research, or platform-policy analysis — get a consistent numeric ID per entity for joining across data sources, scoped strictly to what a logged-out visitor can already see.

🎥 Product and SaaS development

Link-preview tools, ID-lookup APIs, and CRM-enrichment products can wrap this Actor as their Facebook-resolution backend rather than maintaining their own HTML-parsing and anti-bot layer.

🍚 Input Parameters

All five parameters come directly from the Actor's input schema, in schema order.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	One item per line. Accepts full page/group/post/video/reel/watch/story URLs, profile.php?id=, permalink.php, @handle, bare vanity (e.g. NintendoAmerica), fb.me / m.facebook.com / share links, and — with Reverse mode on — a bare numeric ID resolved back to its canonical URL.	["https://www.facebook.com/NintendoAmerica", "@zuck", "100064368354094"]
reverseMode	No	boolean	When true (default), a bare numeric input is treated as a Facebook ID and resolved to its canonical URL + name. When false, numeric input is instead looked up as a profile.php URL.	true
entityTypes	No	array	Optional allow-list, default [] (keep everything). Enum values: page, profile, group, post. Restricts output to the listed kinds — resolution still happens, but non-matching rows are dropped before push and are not charged.	["page", "group"]
includeRawJson	No	boolean	Default false. Adds a raw field with the underlying Facebook JSON object for each resolved row. Off by default to keep the dataset clean and typed.	false
proxyConfiguration	No	object	Apify Proxy configuration. Prefilled with {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}. If a request is blocked, the Actor automatically escalates datacenter → residential (sticky) regardless of what's configured here.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

Example input

{
  "startUrls": [
    "https://www.facebook.com/NintendoAmerica",
    "https://www.facebook.com/groups/germtheory.vs.terraintheory",
    "https://www.facebook.com/NintendoAmerica/posts/pfbid02JESEPSvyiLGjvewuFYhviAwQjTdxZW1ZfnWTeCzxVWgZLT3xgoLHVDwvuenVRyKKl",
    "100064368354094"
  ],
  "reverseMode": true,
  "entityTypes": [],
  "includeRawJson": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Supported URL types and input formats

The Actor's detect_url_type() and normalize_url() functions accept a wide range of shapes and normalize each to an absolute https://www.facebook.com/... URL before fetching:

• Full URLs across hosts — facebook.com, www.facebook.com, m.facebook.com, web.facebook.com, mobile.facebook.com are all rewritten to www.facebook.com; l.facebook.com/l.php?u=<encoded-url> redirect wrappers are unwrapped to the real target before fetching
• Handles and bare vanity strings — @zuck becomes https://www.facebook.com/zuck; a bare string like NintendoAmerica is treated as a vanity path
• Numeric IDs — with reverseMode on (default), a bare numeric string like 100064368354094 is intercepted before normalization and looked up as an ID; with reverseMode off, the same numeric string is turned into a profile.php?id= URL and resolved forward instead
• Entity-specific path markers used for type detection: /groups/ → group; /posts/, /permalink/, /photo, /photos/, /videos/, /video/, /reel/, /reels/, /watch, /story.php, /media/set, permalink.php, or a story_fbid= query parameter → post; profile.php in the path → profile; anything else → page

Three real examples covering different input shapes: https://www.facebook.com/NintendoAmerica (page, vanity URL), https://www.facebook.com/groups/germtheory.vs.terraintheory (group — the /groups/ marker is checked before any post marker, so a group permalink still resolves as type: "group"), and 100064368354094 with reverseMode on (reverse ID → canonical URL lookup).

📦 Output Format

Every resolved input produces exactly one flat JSON row with the same 20 columns; fields that don't apply to that entity type are null, never omitted. The dataset's default view surfaces all 20 columns. Export from the Apify Console as JSON, CSV, Excel, XML, or via the API/apify_client in any of those formats — standard Apify dataset export, nothing bespoke to this Actor.

Output for a page

{
  "facebookUrl": "https://www.facebook.com/NintendoAmerica",
  "facebookId": "100064368354094",
  "resolved": true,
  "type": "page",
  "entityName": "Nintendo of America",
  "username": "NintendoAmerica",
  "canonicalUrl": "https://www.facebook.com/NintendoAmerica",
  "category": "Video Game Company",
  "isVerified": true,
  "followerCount": 5338483,
  "likeCount": 5338483,
  "memberCount": null,
  "joinState": null,
  "adLibraryId": "119240841493711",
  "profilePictureUrl": "https://scontent.xx.fbcdn.net/v/nintendo-profile.jpg",
  "authorName": null,
  "authorId": null,
  "createdAt": null,
  "postId": null,
  "scrapedAt": "2026-07-26T09:14:02Z"
}

Output for a group

{
  "facebookUrl": "https://www.facebook.com/groups/germtheory.vs.terraintheory",
  "facebookId": "430027810407566",
  "resolved": true,
  "type": "group",
  "entityName": "Germ Theory vs Terrain Theory",
  "username": null,
  "canonicalUrl": "https://www.facebook.com/groups/430027810407566",
  "category": null,
  "isVerified": null,
  "followerCount": null,
  "likeCount": null,
  "memberCount": 12400,
  "joinState": "NOT_A_MEMBER",
  "adLibraryId": null,
  "profilePictureUrl": "https://scontent.xx.fbcdn.net/v/group-cover.jpg",
  "authorName": null,
  "authorId": null,
  "createdAt": null,
  "postId": null,
  "scrapedAt": "2026-07-26T09:14:19Z"
}

Output for a post

{
  "facebookUrl": "https://www.facebook.com/NintendoAmerica/posts/pfbid02JESEPSvyiLGjvewuFYhviAwQjTdxZW1ZfnWTeCzxVWgZLT3xgoLHVDwvuenVRyKKl",
  "facebookId": "684213590812335",
  "resolved": true,
  "type": "post",
  "entityName": "Nintendo of America on Facebook",
  "username": null,
  "canonicalUrl": "https://www.facebook.com/NintendoAmerica/posts/684213590812335",
  "category": null,
  "isVerified": null,
  "followerCount": null,
  "likeCount": null,
  "memberCount": null,
  "joinState": null,
  "adLibraryId": null,
  "profilePictureUrl": "https://scontent.xx.fbcdn.net/v/post-thumbnail.jpg",
  "authorName": "Nintendo of America",
  "authorId": "100064368354094",
  "createdAt": "2026-06-30T17:05:00Z",
  "postId": "pfbid02JESEPSvyiLGjvewuFYhviAwQjTdxZW1ZfnWTeCzxVWgZLT3xgoLHVDwvuenVRyKKl",
  "scrapedAt": "2026-07-26T09:14:41Z"
}

Note facebookId on a post row is the numeric story ID — never the pfbid... token, which is Facebook's opaque permalink identifier, not a real numeric object ID. That token is preserved separately as postId so neither value is lost.

Schema stability and export options

The column set (OUTPUT_FIELDS) is fixed in the Actor's source and does not change shape when Facebook's front end changes — a redesign that alters how a field is embedded in the page's script tags requires an Actor code update, but does not add or remove columns from the dataset your pipeline already parses. Fields the extractor cannot find are returned as null, never dropped from the row and never guessed. Results export from the Apify Console or API as JSON, CSV, Excel (XLSX), XML, RSS, or HTML table — the standard Apify dataset export formats; there is no separate or additional export mechanism specific to this Actor.

💡 Facebook URL → ID Plus Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run from your application whenever a new Facebook link enters your system — a lead form, a CRM record, an inbound webhook. Pass that single URL as the only item in startUrls, run the Actor via apify_client, and read back facebookId, entityName, category, and adLibraryId from the pushed row to write into the destination record. Because unresolved links are never pushed, a resolved: true row is the trigger to proceed; an empty dataset means the link didn't resolve and the record should be flagged for manual review instead.

🎯 Strategy 2: Scheduled monitoring and alerting

Run the same list of Page or Group URLs on an Apify Schedule (daily or weekly) and diff each run's followerCount, likeCount, or memberCount against the previous run's dataset for the same facebookId. Alert when the delta on the field you care about crosses a threshold you define — the Actor doesn't compute the diff itself, so this comparison happens in whatever consumes the dataset (a script polling the Apify API, or a webhook-triggered function reading the latest run's items).

🎯 Strategy 3: Bulk dataset build

Feed a large startUrls list — one line per link — in a single run, or split the list across parallel runs keyed by entity type using entityTypes to keep each run's output homogeneous (e.g. one run with entityTypes: ["page"], another with ["group"]). Aggregate the resulting datasets to CSV or load them into a database via the Apify API. The schema has no documented concurrency or item-count limit in the input definition; size your batches to your own proxy budget and run-timeout tolerance instead.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	CRM/lead-form ID resolution on demand	Single-URL run per event, triggered by your app	JSON row via apify_client
Scheduled monitoring	Tracking follower/member growth over time	Recurring run on an Apify Schedule, same URL list each time	Dataset diffed run-over-run
Bulk dataset build	Building a research or training dataset	One large run or several parallel runs split by entityTypes	CSV/database export

🌴 Related Facebook Scrapers & Tools

Scraper Name	What it extracts
Facebook Page Posts & Comments Scraper (Scrapio)	Ongoing post content and comment threads from a Facebook Page
Facebook Group Posts & Engagement Scraper (Scrapio)	Post activity and engagement metrics inside a Facebook Group
Facebook Posts Search Scraper With AI Enrichment (Scrapio)	Keyword-driven post discovery with AI-generated enrichment fields
Facebook Reels Scraper With Engagement Analytics (Scrapio)	Reel video content and engagement metrics

How to integrate Facebook URL → ID Plus with your stack

Facebook URL → ID Plus works with any language or tool that can make an HTTP request to the Apify API — the examples below use Apify's official client libraries, which wrap that API.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "startUrls": [
        "https://www.facebook.com/NintendoAmerica",
        "https://www.facebook.com/groups/germtheory.vs.terraintheory",
        "@zuck",
    ],
    "reverseMode": True,
    "entityTypes": [],
    "includeRawJson": False,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
}

run = client.actor("facebook-url-to-id-plus").call(run_input=run_input)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("facebook_ids.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()) if rows else [])
    writer.writeheader()
    writer.writerows(rows)

print(f"Resolved {len(rows)} of {len(run_input['startUrls'])} inputs")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_API_TOKEN>' });

const run = await client.actor('facebook-url-to-id-plus').call({
    startUrls: [
        'https://www.facebook.com/NintendoAmerica',
        'https://www.facebook.com/groups/germtheory.vs.terraintheory',
    ],
    reverseMode: true,
    entityTypes: [],
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ['RESIDENTIAL'] },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Resolved ${items.length} rows`);
items.forEach((row) => console.log(row.facebookUrl, '->', row.facebookId));

Async and scheduled pipelines

For large startUrls lists, start the run asynchronously via client.actor("facebook-url-to-id-plus").start(run_input=...) and poll the run status or the dataset item count from your own process rather than holding a connection open with .call(). For recurring resolution jobs, use an Apify Schedule to trigger the same input on a fixed cadence and read the latest run's dataset from your pipeline afterward — the Actor itself has no built-in webhook-on-completion feature beyond what Apify's platform-level webhooks provide for any Actor run.

🎯 Who Needs Facebook URL → ID Plus? (Use Cases & Industries)

🏢 CRM and ad-ops teams

An ad-ops analyst pastes a list of client Page URLs and gets back facebookId and adLibraryId for each — the two fields needed to key a Page into an internal ads-mapping table without hand-copying IDs from each Page's "About" section.

📊 Data engineers building enrichment pipelines

A data engineer wires this Actor into an inbound lead pipeline: any Facebook URL captured on a form gets resolved to facebookId and entityName before it's written to the CRM, so duplicate leads pointing at the same Page (via different vanity URLs) collapse to one record.

📱 Marketing and competitive intelligence teams

A marketing analyst tracks a competitor set's followerCount and likeCount across weekly scheduled runs to chart relative audience growth, and checks adLibraryId presence to see which competitors are actively running ads through Meta.

🔬 Researchers

Academic and market researchers use the numeric facebookId as a stable join key across a public-entity dataset — for social-network mapping or platform-policy studies — scoped to what's visible without logging in.

🎥 SaaS and API product builders

Teams building a link-preview widget, an ID-lookup micro-API, or a CRM-enrichment add-on can call this Actor as the resolution backend instead of maintaining their own Facebook HTML parser and proxy-escalation logic.

Is it legal to scrape Facebook?

Scraping publicly accessible web data is generally lawful in the United States: in hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), the Ninth Circuit held that scraping data that is not behind a login wall does not violate the Computer Fraud and Abuse Act. That principle is why this Actor fetches only what a logged-out visitor can already see — no login, no session, no bypass of any access control.

A separate, narrower risk applies specifically to Facebook: in Facebook, Inc. v. Power Ventures, Inc., 844 F.3d 1058 (9th Cir. 2016), the same court held that continuing to access Facebook's systems after Facebook has explicitly revoked access (a cease-and-desist notice, an IP block that is then circumvented) can constitute a CFAA violation, distinct from the general legality of scraping public pages. This Actor's proxy escalation (datacenter → residential) responds to ordinary anti-bot blocking on public pages; it does not attempt to circumvent an explicit access revocation.

Separately, scraping in violation of Facebook's Terms of Service is a contract question, not a criminal one — it can expose an account or business to civil claims or a platform ban, independent of whether the CFAA is implicated.

Data protection law (GDPR, CCPA) attaches when the resolved entity is a natural person's personal Profile — entityName, username, and profilePictureUrl on a profile row are personal data under GDPR when the data subject is identifiable and in scope. It generally does not attach to Page or Group entities representing a business, brand, or organization, which are not "personal data" under GDPR in the same sense. Facebook URL → ID Plus returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does Facebook URL → ID Plus work without a Facebook account?

Yes. Every fetch is unauthenticated — the Actor uses curl_cffi with Chrome TLS impersonation to request the same public HTML a logged-out visitor's browser would receive. No Facebook login, session cookie, or API access token is required or accepted as input.

How does Facebook URL → ID Plus handle Facebook's anti-scraping measures?

It escalates proxy tier on a detected block: starting from no proxy (or your configured tier), it retries through Apify's datacenter proxy and then residential proxy (sticky — once residential succeeds, subsequent retries for that URL stay on residential), waiting 1.5 seconds between escalation attempts. A response counts as "blocked" when it returns HTTP 403/429/503, redirects to a /login/ or /checkpoint/ path, or returns HTML that is too short or lacks the JSON payload a genuine entity page always embeds. Requests are also sent with Chrome-matching TLS fingerprinting (impersonate: chrome131) and browser-shaped headers.

Can I run Facebook URL → ID Plus at scale without getting blocked?

The Actor's proxy escalation and blocking detector are designed to recover from ordinary rate-limiting and soft blocks automatically; there is no documented uptime guarantee or resolution-rate figure, since outcomes depend on Facebook's own anti-bot behavior at run time, which the Actor doesn't control. The run log reports how many inputs resolved versus were skipped for each run so you can see actual performance for your input list.

How fresh is the data Facebook URL → ID Plus returns?

Fully live — every run fetches the current HTML for each URL at request time; nothing is cached or read from a prior run. scrapedAt on each row is the UTC timestamp of that specific fetch.

Which fields work best for AI training and RAG indexing?

For RAG grounding, entityName and category give a short, structured description of what the resolved entity is; username and canonicalUrl let an agent construct or verify a link. For training data, type, isVerified, and the count fields (followerCount, likeCount, memberCount) are the most consistently structured across every row — every one of the 20 output fields returns as a typed primitive (string, number, boolean, or null), so no string parsing is needed before the field enters a model's context or a training set.

Does Facebook URL → ID Plus return personal data?

Only when the resolved entity is a natural person's Profile — in that case entityName, username, and profilePictureUrl are personal data under GDPR/CCPA. Page and Group rows represent business or organizational entities, not individuals. The Actor returns only publicly available data either way; the lawful basis for storing and using it sits with you as the operator.

Does Facebook URL → ID Plus work with Claude, ChatGPT, and other AI agent tools?

There is no dedicated MCP server for this Actor. It is callable as a standard Apify Actor run by any agent framework that can call the Apify API or the apify_client/apify-client SDKs — every response is typed JSON, so no HTML parsing is needed before the result enters an agent's context.

What happens to a link that Facebook won't resolve?

It is logged as unresolved and skipped — never pushed to the dataset with a null or guessed facebookId, and never billed. The same applies to a resolved entity whose type isn't in your entityTypes allow-list: it's dropped after resolution, before the push, so filtering by entity type never costs you a charged event for a row you didn't want.

How does Facebook URL → ID Plus compare to other Facebook ID scrapers?

apify/facebook-url-to-id (FREE pricing, as observed on the Apify Store, 2026-07-26) covers a similarly broad set of entity types and is free to run, but its own listing notes profile IDs are only available "depending on profile privacy" and it does not document a reverse ID → URL mode. scraper-engine/facebook-url-to-id (flat monthly price, as observed on the Apify Store, 2026-07-26) documents page, group, post, video, and profile coverage with nested per-entity objects (page_data, group_data, post_data). Facebook URL → ID Plus differs on schema shape — one flat row schema across all entity types instead of type-specific nested objects — and adds a documented reverse-lookup mode and an uncharged path for unresolved and filtered rows, which neither competitor's listing documents.

ℹ️ Disclaimer

Facebook URL → ID Plus extracts only publicly available data from Facebook. This tool is intended for lawful use cases only. Users are responsible for complying with Facebook's terms of service and applicable data protection laws in their jurisdiction.