facebook-hashtag-search-scraper-by-creator-follower-filter

Facebook Hashtag Scraper — Extract Posts, Creators and Follower Data

Facebook Hashtag Scraper collects public posts under any Facebook hashtag, then turns that raw post feed into a ranked creator list: it deduplicates every unique author, enriches each one with follower count, page likes, category and a best-effort verification signal, and keeps only the creators that clear a minimum follower threshold you set. Output is typed JSON, not scraped HTML — one row per post, or one row per creator — ready for a spreadsheet, a database or a script without any parsing. This guide documents every input and output field and how teams run it for lead generation, influencer discovery and ongoing hashtag monitoring.

---

What Does Facebook Hashtag Scraper Do?

Facebook Hashtag Scraper is an Apify Actor that scans one or more Facebook hashtags, collects the posts published under them, and layers a creator-intelligence pass on top of the raw feed. It returns two entity types in one run: posts (text, engagement, media) and creators (the deduplicated authors behind those posts, enriched with public page stats).

A Facebook account is required. The hashtag feed's GraphQL endpoints are only served to an authenticated session — the Actor needs your c_user and xs session cookies (or a combined cookie string). Without valid cookies it does not scrape; it finishes cleanly with one free, non-charged record explaining what's missing.

What it does, in one pass:

• Scans one or more hashtags (searchQueries) and pulls up to maxItems posts per hashtag
• Extracts full post data: text, reaction breakdown, comment/share counts, video view counts, timestamps, post URL and media attachments
• Enriches video/reel attachments with the same detailed playback and reel metadata Facebook's own player consumes
• Deduplicates every unique post author across all collected posts into a creator list
• Enriches each creator with follower count, page likes, category and a best-effort verified flag
• Filters creators by minimum follower count (minFollowers) and/or verification (verifiedOnly)
• Optionally collapses the output into one row per creator (groupByCreator), tagging each with how many posts they published under that hashtag

---

Features & Capabilities

The feature set splits into three layers: post collection, creator enrichment, and network resilience.

Core features

• Bulk hashtag scanning — searchQueries accepts plain words (marketing) or full hashtag URLs (https://www.facebook.com/hashtag/marketing), normalized and deduplicated case-insensitively
• Full post payload — postId, url, text, topReactions (per reaction-type counts), commentsCount, sharesCount, videoViewCount, time, timestamp
• Author identity on every post — user.name, user.id, user.url, user.avatar, independent of whether creator enrichment is on
• Creator enrichment layer — creator.followers, creator.likes, creator.category, creator.verified fetched from each unique author's public page
• Follower-gated shortlisting — minFollowers drops any creator below the threshold before the row is written (and billed)
• Grouped or per-post output — groupByCreator switches between one row per post and one row per creator, adding postCountUnderHashtag either way
• Reel/video enrichment — video attachments are enriched with DASH manifest data, progressive playback URLs, duration and thumbnail via a dedicated reel-detail request
• Sticky residential proxy with checkpoint detection — a single stable exit IP per run, escalating only on genuine block signals, never scattering the same login across many IPs

How Facebook Hashtag Scraper compares to other Facebook scrapers

Feature	Facebook Hashtag Scraper	easyapi Facebook Hashtag Scraper	datapilot Facebook Hashtag Search Scraper
Output format	Typed JSON, stable schema	Typed JSON	Typed JSON
Post engagement fields (reactions, comments, shares, video views)	✅	✅	✅ (documented in output table)
Creator/author enrichment (followers, likes, category, verified)	✅	❌ not documented	❌ not documented
Follower-threshold filtering	✅ minFollowers	❌ not documented	❌ not documented
Group posts by creator	✅ groupByCreator	❌ not documented	❌ not documented
Reel/video playback metadata	✅	✅ (shown in their own output sample)	Not shown in their output sample
Live scrape vs. sample data	Live authenticated scrape	Live scrape per their README	Their own README states the current implementation "generates sample posts" as a demonstration and that real scraping logic can be swapped in — observed 2026-07-26
Authentication required	Facebook session cookies (c_user + xs)	Not documented as required	Not documented as required

If your use case is feeding structured data to an LLM or a lead-scoring pipeline, the creator-enrichment row is the decision-maker: a plain hashtag scraper hands you post authors as a bare name/ID/URL object, leaving you to look up follower counts yourself, one profile at a time. This Actor does that lookup inline, deduplicated across the whole run, and lets you gate on the result before it's even written to the dataset.

When another tool might suit you better

If your target is Instagram rather than Facebook, this Actor is the wrong pick — use a hashtag scraper built for that platform's search API and page structure instead (Scrapio's Instagram Hashtag Analytics Scraper covers that entity). And if you only need raw post volume or trend velocity for a hashtag — no creator-level detail at all — a simpler post-only hashtag scraper will run fewer requests per unique author and won't need Facebook session cookies to start, since it skips the enrichment pass entirely.

Facebook Hashtag Scraper within the Scrapio data stack

Facebook Hashtag Scraper covers hashtag posts and the creators behind them. For Facebook Page-level reviews and sentiment, use Facebook Pages Scraper: Review Sentiment Analysis. For deeper per-video engagement auditing on Reels you already have URLs for, use Facebook Videos Scraper With Reactions & Comment Counts. For discovering the Groups themselves rather than hashtag posts, use Facebook Groups Search Scraper By Member Count & Keyword Match.

---

Why do developers and data teams scrape Facebook hashtags?

Hashtag feeds are the one place on Facebook where posts from accounts you don't already follow surface by topic, which is why the audiences below reach for them.

🏢 Growth, marketing and influencer teams

A common workflow: put a niche hashtag list into searchQueries (e.g. ["skincare", "clean-beauty"]), set minFollowers to a real qualifying threshold like 5000, turn on groupByCreator, and run. The dataset comes back as a deduplicated shortlist of accounts actively posting in that niche, each with a resolved creator.followers, creator.likes and creator.category — ready to filter further in a spreadsheet or push straight into a CRM or outreach tool. Because postCountUnderHashtag is on every row, teams can also rank candidates by how active they are in the niche, not just by follower size.

📊 AI training data and RAG indexing

The text field (the raw post caption) is the highest-information field for semantic search — index it alongside creator.category and creator.name so a RAG system can answer "who's posting about X" with real attribution. For training data, topReactions, commentsCount, sharesCount and creator.followers are the fields with the most consistent structure across every row, useful for engagement-prediction or creator-classification models. Every field returns as a typed primitive — a string, number, boolean or nested object — so no text cleanup or type coercion is needed before it hits a training set or an embedding pipeline.

📱 Competitive and market intelligence

Point the Actor at a competitor's branded or campaign hashtag and track which creators are amplifying it, at what follower tier (creator.followers), and how the post-level engagement (commentsCount, sharesCount, topReactions) shifts across scheduled runs. A rising postCountUnderHashtag for a given creator.id week over week is a direct signal that a specific account is becoming a repeat amplifier of that campaign.

🔬 Research and academic use

Academic and social-research projects use hashtag feeds to study how topics and campaigns spread across public accounts — creator category distribution, reaction-type ratios, or posting cadence within a niche. The Actor returns only what Facebook already shows an anonymous browser could see on the hashtag page and each creator's public page; it does not access private groups, private profiles or anything behind a login wall belonging to someone else.

🎥 Product and SaaS development

Teams building an influencer-discovery tool, a lead-enrichment API, or a niche-monitoring dashboard use the creator object as the enrichment backbone: followers, likes, category and verified map directly onto typical "creator profile" fields in a product database, without building and maintaining a Facebook page-scraping module in-house.

---

🍚 Input Parameters

All parameters are read directly from .actor/actor.json. Only searchQueries is required by the schema; in practice a valid Facebook session (c_user + xs, or fbCookie) is also needed for the Actor to return post data — see the FAQ below.

Parameter	Required	Type	Description	Example Value
searchQueries	Yes	array	One or more Facebook hashtags to scan — plain words (football, travel) or full hashtag URLs (https://www.facebook.com/hashtag/football). Every unique author found under these hashtags becomes a creator candidate. Default: ["football"].	["marketing", "startup"]
maxItems	No	integer	How many posts to read per hashtag before grouping/filtering creators. More posts means more unique creators discovered. The schema notes Facebook caps a hashtag feed at roughly 200 posts. Default: 10. Minimum: 1. Maximum: 10000.	50
groupByCreator	No	boolean	When true, collapses all posts by the same author into a single row and adds postCountUnderHashtag (how many posts that creator published under the hashtag). When false, emits one row per post, with each post still carrying its own enriched creator object. Default: false.	true
enrichCreatorStats	No	boolean	Fetches each unique author's public Facebook page/profile and adds follower count, page likes, category and a best-effort verified flag to the creator object. Adds one extra request per unique creator. Pages expose followers reliably; personal profiles often do not (returned as null). Default: true.	true
minFollowers	No	integer	Keeps only creators whose follower count is greater than or equal to this number. 0 disables the filter. Requires enrichCreatorStats. Creators with an unknown follower count are kept only when this is 0. Default: 0. Minimum: 0.	5000
verifiedOnly	No	boolean	Keeps only creators whose page shows a verification signal. Best-effort — Facebook does not expose the blue badge cleanly on every logged-out page, so leave this off unless you specifically need verified accounts. Default: false.	false
c_user	No	string	Your Facebook c_user cookie (numeric user ID). Found in DevTools → Application → Cookies → www.facebook.com. Use a healthy, non-locked account. Leave blank if you use fbCookie instead.	"100004XXXXXXXXX"
fbCookie	No	string (secret)	Alternative to c_user + xs: paste the full Facebook cookie string containing c_user=... and xs=... (e.g. from DevTools → Network → Request Headers → cookie). Overrides the individual fields if set. Marked isSecret — masked in the Console and encrypted at rest.	"c_user=100004XXXXXXXXX; xs=XX%3AXXXXXXXXXXXXXX%3A..."
xs	No	string (secret)	Your Facebook xs cookie (URL-encoded session token). Found in DevTools → Application → Cookies → www.facebook.com. Grants access to your account. Marked isSecret — masked in the Console and encrypted at rest. Leave blank if you use fbCookie instead.	"XX%3AXXXXXXXXXXXXXX%3A..."
proxyConfiguration	No	object	By default the Actor runs on a sticky residential IP (best fit for logged-in Facebook). If you configure a proxy here it is honoured but still pinned to a single sticky session for the whole run. Default: {"useApifyProxy": false}.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

c_user is a plain text field in the schema (not marked secret) — treat it as sensitive anyway, since it identifies your Facebook account.

JSON input example:

{
  "searchQueries": ["marketing", "startup"],
  "maxItems": 50,
  "groupByCreator": true,
  "enrichCreatorStats": true,
  "minFollowers": 5000,
  "verifiedOnly": false,
  "c_user": "100004XXXXXXXXX",
  "xs": "XX%3AXXXXXXXXXXXXXX%3A...",
  "proxyConfiguration": { "useApifyProxy": false }
}

Supported hashtag formats and input examples

searchQueries accepts a bare word, a #-prefixed word, or a full hashtag URL — all are normalized to the same slug internally, and duplicates (case-insensitive) are dropped before scanning starts.

1. Plain hashtags for a niche shortlist:

{
  "searchQueries": ["skincare", "clean-beauty"],
  "groupByCreator": true,
  "minFollowers": 5000,
  "c_user": "100004XXXXXXXXX",
  "xs": "XX%3AXXXXXXXXXXXXXX%3A..."
}

2. A full hashtag URL, mixed with a plain word — both resolve to the same normalized slug:

{
  "searchQueries": ["https://www.facebook.com/hashtag/startup", "founders"],
  "maxItems": 200,
  "fbCookie": "c_user=100004XXXXXXXXX; xs=XX%3AXXXXXXXXXXXXXX%3A..."
}

3. Verified-only accounts above a high follower bar, per-post mode (no grouping):

{
  "searchQueries": ["travel"],
  "maxItems": 100,
  "groupByCreator": false,
  "minFollowers": 50000,
  "verifiedOnly": true,
  "c_user": "100004XXXXXXXXX",
  "xs": "XX%3AXXXXXXXXXXXXXX%3A..."
}

---

📦 Output Format

Every run writes typed, normalized JSON rows to the Actor's Apify dataset — no HTML, no manual parsing. The schema is identical in shape whether groupByCreator is on or off; only which post becomes the row's representative changes. Data can be exported from the Storage tab (or via the API) as JSON, JSONL, CSV, Excel, HTML table or XML.

Output for a post row (per-post mode)

With groupByCreator: false, one row is written per collected post, each already carrying its enriched creator object:

{
  "searchQuery": "startup",
  "postId": "122168152748145259",
  "user": {
    "name": "Build In Public HQ",
    "id": "61554357771285",
    "url": "https://www.facebook.com/profile.php?id=61554357771285",
    "avatar": "https://scontent.xx.fbcdn.net/v/t39.30808-1/429972849_n.jpg"
  },
  "url": "https://www.facebook.com/122168152748145259",
  "text": "Bootstrapped to $10k MRR in 90 days — here's what we learned. #startup #founders",
  "topReactions": {
    "Like": 842,
    "Love": 213,
    "Care": 12,
    "Wow": 9,
    "Haha": 4,
    "Angry": 0,
    "Sad": 0
  },
  "commentsCount": 96,
  "sharesCount": 41,
  "videoViewCount": 0,
  "time": "2026-06-18 14:02:05",
  "timestamp": 1750248125,
  "attachments": [
    {
      "deduplication_key": "0119ac5697c575b62f508b681459152f",
      "target": { "__typename": "Photo", "id": "890215566" },
      "__typename": "StoryAttachment",
      "style_list": ["photo", "fallback"],
      "styles": { "__typename": "StoryAttachmentPhotoStyleRenderer" },
      "media": { "__typename": "Photo", "id": "890215566" },
      "all_subattachments": { "nodes": [] }
    }
  ],
  "creator": {
    "name": "Build In Public HQ",
    "id": "61554357771285",
    "url": "https://www.facebook.com/profile.php?id=61554357771285",
    "avatar": "https://scontent.xx.fbcdn.net/v/t39.30808-1/429972849_n.jpg",
    "followers": 48210,
    "likes": 47655,
    "category": "Business service",
    "verified": false,
    "postCountUnderHashtag": 3
  },
  "postCountUnderHashtag": 3,
  "passedFollowerFilter": true
}

Every top-level key: searchQuery (the hashtag this post was found under), postId, user (the raw author object — name, id, url, avatar, unrelated to whether enrichment ran), url (post permalink), text, topReactions (object keyed by reaction label), commentsCount, sharesCount, videoViewCount, time (formatted local timestamp), timestamp (Unix epoch), attachments (array — see below), creator (the enriched author object), postCountUnderHashtag (posts by this author under this hashtag, in this run), and passedFollowerFilter.

attachments[] mirrors the shape Facebook's own feed API returns per attachment: deduplication_key, target.__typename (Photo, Video, etc.) and target.id, styles, media, and all_subattachments. When an attachment's target.__typename is Video, the Actor makes a second request per video and replaces styles/media with the richer reel-detail payload — DASH manifest data, progressive playback URLs, duration and thumbnail — inside the same attachments[] entry, so the post row's shape never changes.

One field is worth calling out directly: passedFollowerFilter is always true on every row that reaches the dataset. Creators that fail minFollowers or verifiedOnly are never written at all — the filter drops the row instead of tagging it false. The field name is a leftover of how the check works internally; treat every row you see in the dataset as already having passed.

The dataset's default view (🔥 Posts & Creators) surfaces all 15 top-level keys above — nothing is hidden behind the view for this Actor's normal rows.

Output for a creator row (grouped mode)

With groupByCreator: true, the schema is identical, but posts by the same author under the same hashtag collapse into one row. The row's post-level fields (text, topReactions, commentsCount, etc.) come from that creator's single highest-engagement post under the hashtag — the representative — while postCountUnderHashtag reflects the creator's real total post count under that hashtag, not just the representative post:

{
  "searchQuery": "startup",
  "postId": "122168152748145301",
  "user": {
    "name": "Build In Public HQ",
    "id": "61554357771285",
    "url": "https://www.facebook.com/profile.php?id=61554357771285",
    "avatar": "https://scontent.xx.fbcdn.net/v/t39.30808-1/429972849_n.jpg"
  },
  "url": "https://www.facebook.com/122168152748145301",
  "text": "Our biggest launch thread yet — full breakdown of the funnel that got us here. #startup",
  "topReactions": { "Like": 1204, "Love": 340, "Care": 18, "Wow": 22, "Haha": 6, "Angry": 0, "Sad": 0 },
  "commentsCount": 187,
  "sharesCount": 96,
  "videoViewCount": 0,
  "time": "2026-06-22 09:15:41",
  "timestamp": 1750583741,
  "attachments": [],
  "creator": {
    "name": "Build In Public HQ",
    "id": "61554357771285",
    "url": "https://www.facebook.com/profile.php?id=61554357771285",
    "avatar": "https://scontent.xx.fbcdn.net/v/t39.30808-1/429972849_n.jpg",
    "followers": 48210,
    "likes": 47655,
    "category": "Business service",
    "verified": false,
    "postCountUnderHashtag": 7
  },
  "postCountUnderHashtag": 7,
  "passedFollowerFilter": true
}

Schema stability and export options

Field names stay fixed regardless of how Facebook's own front end changes, because the extraction logic reads Facebook's internal GraphQL response structure directly rather than parsing rendered HTML — a front-end redesign does not change the field names in this dataset. If a run finds no cookies, expired cookies, a locked account, or zero creators surviving the filters, the Actor writes exactly one extra, diagnostic-only record instead of failing the run: it carries the same 15 keys zero-filled or empty, plus two extra keys, status and message, explaining what happened. That record is pushed without the row_result charge — it costs nothing. To exclude it from downstream processing, filter on postId !== "" (real rows always have a non-empty postId; the diagnostic row does not).

---

💡 Facebook Hashtag Scraper Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Use case: enrich an inbound lead or contact record with a Facebook creator's public profile stats the moment it arrives. Workflow: your system triggers a run via the Apify API with searchQueries set to the relevant niche hashtag(s) and minFollowers set to your qualifying bar → the Actor runs and returns rows with creator.followers, creator.category and creator.verified already resolved → your pipeline reads those fields straight out of the dataset and writes them back into the source record (CRM, spreadsheet, internal API) without a separate lookup step.

🎯 Strategy 2: Scheduled monitoring and alerting

Use case: track a branded or campaign hashtag over time. Workflow: set up a recurring run on an Apify Schedule with groupByCreator: true → each run's dataset gives you a fresh creator list keyed by creator.id → diff it against the previous run's creator.followers and postCountUnderHashtag for the same creator.id → alert when a high-follower creator appears for the first time, or when a known creator's postCountUnderHashtag jumps, since that signals a new wave of amplification.

🎯 Strategy 3: Bulk dataset build

Use case: build a research or lead dataset spanning many hashtags in one pass. Workflow: list every hashtag you need in the searchQueries array (it accepts as many as you want in one run) → set maxItems to the depth you need per hashtag → let the run finish → export the full dataset to CSV or load it straight into a database via the API. Hashtags in searchQueries are processed one after another within a single run, not in parallel — for very large hashtag lists, splitting across a few smaller runs will finish sooner than one very large run.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Qualifying inbound leads/contacts on demand	Single triggered run per event, via API	JSON, read field-by-field
Scheduled monitoring	Tracking a hashtag's creator base over time	Recurring run on an Apify Schedule	JSON dataset per run, diffed externally
Bulk dataset build	Research or lead lists across many hashtags at once	One run with a bulk searchQueries array	CSV / Excel export, or API pull into a database

---

🌴 Related Facebook Scrapers & Tools

Scraper Name	What it extracts
Facebook Pages Scraper: Review Sentiment Analysis	Facebook Page data plus visitor reviews, recommend-rate rollup and sentiment
Facebook Videos Scraper With Reactions & Comment Counts	Anchored, per-video reaction/comment/share counts and full technical video record
Facebook Groups Search Scraper By Member Count & Keyword Match	Facebook Group discovery filtered by member count and keyword
Facebook Search Scraper (Video & Reel Search)	Facebook Watch video and Reel search results
Facebook Video Search Scraper By Newest & Date Range	Newest-first Facebook Watch results inside a date window
facebook-group-admin-contact-scraper	Facebook Group admin/moderator contact details
facebook-group-post-media-extractor	Media attachments from Facebook Group posts
facebook-page-video-transcript-scraper	Transcripts of videos published on a Facebook Page
Instagram Hashtag Analytics Scraper	Instagram hashtag post and creator analytics (same entity, different platform)
Tiktok Trending Hashtags Analytics Scraper & Top Videos	TikTok trending hashtags plus the top videos and creators behind them

---

How to integrate Facebook Hashtag Scraper with your stack

Facebook Hashtag Scraper works with any language or tool that can make an HTTP request to the Apify API — there is no separate signup, API key format or SDK beyond the standard Apify client libraries.

Python

import csv
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run_input = {
    "searchQueries": ["marketing", "startup", "founders"],
    "maxItems": 100,
    "groupByCreator": True,
    "minFollowers": 5000,
    "c_user": "100004XXXXXXXXX",
    "xs": "XX%3AXXXXXXXXXXXXXX%3A...",
}

run = client.actor("<YOUR_USERNAME>/facebook-hashtag-search-scraper-by-creator-follower-filter").call(
    run_input=run_input
)

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

with open("creators.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["hashtag", "creator_name", "followers", "category", "posts_under_hashtag"])
    for row in rows:
        if not row.get("postId"):
            continue  # skip the free diagnostic row, if any
        c = row.get("creator") or {}
        writer.writerow([row["searchQuery"], c.get("name"), c.get("followers"),
                          c.get("category"), row.get("postCountUnderHashtag")])

Node.js

import { ApifyClient } from 'apify-client';
import { writeFileSync } from 'fs';

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

const run = await client.actor('<YOUR_USERNAME>/facebook-hashtag-search-scraper-by-creator-follower-filter').call({
    searchQueries: ['marketing', 'startup'],
    groupByCreator: true,
    minFollowers: 5000,
    c_user: '100004XXXXXXXXX',
    xs: 'XX%3AXXXXXXXXXXXXXX%3A...',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const creators = items
    .filter((row) => row.postId)
    .map((row) => ({ hashtag: row.searchQuery, ...row.creator }));

writeFileSync('creators.json', JSON.stringify(creators, null, 2));

Async and scheduled pipelines

Runs can be started asynchronously through the Apify API — fire a run and poll it, or wait synchronously for smaller jobs. For recurring collection (tracking a hashtag over days or weeks), configure an Apify Schedule in the Console to trigger runs on a cron interval, and read each run's defaultDatasetId from the API afterward rather than polling continuously. This suits large hashtag lists or long-running monitoring better than keeping a connection open for the whole run.

---

Who Needs Facebook Hashtag Scraper? (Use Cases & Industries)

🏢 Growth, marketing and influencer teams

A skincare brand scanning ["cleanbeauty", "skincareroutine"] with minFollowers: 10000 and groupByCreator: true gets back a ranked, deduplicated list of active creators in the niche, each with creator.followers and creator.category resolved — a direct input to an influencer-outreach spreadsheet or CRM import, without manually opening dozens of profiles to check follower counts by hand.

📊 AI / ML and RAG teams

Teams building a retrieval index over social content pull text for the semantic layer and creator.category, creator.verified and topReactions as structured metadata filters, so a query like "verified skincare creators talking about retinol" resolves against real, typed fields instead of free-text guessing.

📱 Competitive and market intelligence analysts

An analyst tracking a competitor's campaign hashtag runs the Actor on a schedule, watching postCountUnderHashtag per creator.id to see which accounts are repeat amplifiers, and commentsCount / sharesCount to see which specific posts are actually landing versus just being posted.

🔬 Researchers

Academic teams studying how topics or campaigns spread across public accounts use the hashtag feed as a public, structured data source — creator category distribution and reaction-type mix under a hashtag, without needing accounts of their own to be part of the conversation being studied. Public data only; no private groups or gated profiles are accessed.

🎥 SaaS and product builders

Teams shipping an influencer-discovery or lead-enrichment product use the creator object — followers, likes, category, verified — as the backing data for a "creator profile" feature, without maintaining an in-house Facebook page-scraping module.

---

Is it legal to scrape Facebook hashtags?

Scraping publicly accessible data from the web is generally lawful in the United States. In hiQ Labs v. LinkedIn (9th Cir. 2019, decision reaffirmed on remand in 2022), the court held that scraping data a website makes publicly available does not violate the Computer Fraud and Abuse Act. That principle covers public hashtag posts and public page/profile data of the kind this Actor returns.

Separately, using scraped data in a way that violates Facebook's Terms of Service can expose you to civil claims (breach of contract) from Facebook — a different, non-criminal risk from CFAA liability, and one that exists independently of whether the underlying data was public.

Because this Actor returns personal data — a creator's name, profile URL, avatar and follower count are personal data about an identifiable individual — GDPR (for EU/UK data subjects) and CCPA (for California residents) obligations can attach to how you store and use it, separate from whether collecting it was itself lawful.

Facebook Hashtag Scraper 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 Hashtag Scraper work without a Facebook account?

No. The hashtag feed's GraphQL endpoints are only served to a logged-in session. Without a valid c_user + xs pair (or a fbCookie string containing both), the Actor does not attempt to scrape — it finishes the run successfully with a single free, non-charged record explaining that credentials are required.

How does Facebook Hashtag Scraper handle Facebook's anti-scraping measures?

It reads its GraphQL session tokens and document IDs directly from the live hashtag page on every run rather than hardcoding them, so it does not depend on values that go stale when Facebook changes its front-end bundle. It detects a logged-out response and an account-checkpoint (security lock) page separately from a generic block, and it runs on a single sticky residential exit IP for the whole run by default — rotating to a fresh residential IP only after a genuine block response, up to 3 rotations, rather than hopping IPs on every request. Pagination requests are spaced out with a jittered delay rather than fired back to back.

Can I run Facebook Hashtag Scraper at scale without getting blocked?

There is no published uptime or success-rate guarantee. What is documented in the code: pagination for a single hashtag stops at 60 pages regardless of maxItems, and the input schema separately notes that Facebook itself caps a hashtag feed at roughly 200 posts — so maxItems values well beyond that ceiling will not yield more results. If an account gets checkpointed mid-run, the Actor detects it and stops immediately with an explanatory message rather than retrying uselessly, since a locked account cannot be scraped from any IP.

How fresh is the data Facebook Hashtag Scraper returns?

Every run performs a live fetch — the Actor authenticates fresh and reads the current hashtag feed and each creator's current public page on every run. Nothing is cached or reused between runs.

Which Facebook fields work best for AI training and RAG indexing?

For RAG, index text (the post caption) — it's the highest-information free-text field, and pairing it with creator.name and creator.category lets a retrieval system answer attribution-style questions. For training data, topReactions, commentsCount, sharesCount, videoViewCount and creator.followers are the most consistently structured numeric fields across every row. Every field returns as a typed primitive or nested object — no HTML entities or markup to strip.

Does Facebook Hashtag Scraper comply with GDPR?

The Actor returns only publicly available Facebook data — nothing behind a login wall or friend-list gate. It does not itself retain data beyond the run's dataset. Because creator fields (name, profile URL, avatar, follower count) constitute personal data, the lawful basis for storing and using that data — and any GDPR or CCPA obligations that follow — sits with you as the operator, not with the Actor.

Does Facebook Hashtag Scraper work with Claude, ChatGPT and other AI agent tools?

It is not published through an MCP server. It is callable as a standard HTTP endpoint through the Apify API by any agent framework that can make an HTTP request — LangChain, a custom tool-calling loop, or a direct API call from inside an agent's tool set. Every response is typed JSON, so no HTML parsing step is needed before the data enters an LLM's context window.

What happens if minFollowers or verifiedOnly filters out every creator?

The run still finishes successfully with a non-empty dataset. If posts were collected but no creator passed the filter, the Actor writes one free, non-charged diagnostic record naming how many posts were collected and suggesting a lower minFollowers threshold — many hashtag authors are personal profiles that don't expose a public follower count at all, and are only kept when the filter is disabled (minFollowers: 0).

How does Facebook Hashtag Scraper compare to other Facebook scrapers?

Against easyapi's Facebook Hashtag Search Scraper: their listing documents the same core post fields (reactions, comments, shares, video views, attachments) but does not document creator enrichment, follower-based filtering or grouping by author — this Actor adds that layer, at the cost of requiring Facebook session cookies that easyapi's listing does not document needing. Against datapilot's Facebook Hashtag Search Scraper: their own README states the current implementation generates sample posts to demonstrate the data structure, with real scraping logic left to be added by the user (observed 2026-07-26) — this Actor performs a live authenticated scrape on every run.

---

Disclaimer

Facebook Hashtag Scraper 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.