# Facebook Hashtag Posts | No Login, Exact Reactions & Videos (`feedminer/facebook-hashtag-posts`) Actor

Paste hashtags and get one row per public post Facebook lists under each: text, hashtags, author, date, exact reactions, comments, shares, video views, photos and MP4 links. Top and Latest tabs, plus an optional month-by-month post search. No Facebook account, login or cookies needed.

- **URL**: https://apify.com/feedminer/facebook-hashtag-posts.md
- **Developed by:** [FeedMiner](https://apify.com/feedminer) (community)
- **Categories:** Social media
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.24 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

<div style="border-left:3px solid #1C1917;background:#FAFAF9;padding:15px 20px;border-radius:3px">
<strong>Facebook hashtags in, one row per public post Facebook lists under each out: text, hashtags, author and avatar, date, exact reactions in total and by type, comments, shares, video views, photos with their sizes, and videos with their MP4 addresses and DASH manifests, from the hashtag page's Top and Latest tabs and, on request, Facebook's post search month by month, as JSON, CSV or Excel or straight from the API.</strong> No Facebook account, login or cookie is involved, so there is nothing to connect.
</div>

🔓 **Nothing to connect.** No Facebook login, no cookie to paste, no account of yours or of ours. Every read is a request Facebook's own hashtag page and post search make for a visitor who is not logged in, so nothing of yours can expire or be banned. None of the platform runs quoted on this page used a Facebook account.

⚡ **328 posts from three hashtags in 88 seconds.** Measured on platform run `DIR2peEd38HKagiVr` at 256 MB: both tabs of `gardening`, `blackfriday` and `pinalesmagico`. With the post search one month back, sixteen hashtags gave 2 282 posts in 10 minutes 38 seconds (`09a4Rekx2cWr5HGjr`).

💸 **$2.69 per 1 000 posts on the free plan, $2.24 from Gold.** The other Facebook hashtag scraper we compared on the Apify Store on 21 November 2026 charged $2.99 per 1 000 on every plan, plus $0.09 each time a run started. A run of this one starts at $0.00005.

🏷️ **Only the posts that carry your hashtag, and the rest is never billed.** Facebook lists posts under a hashtag whose own text does not carry it. With `onlyTagged` on, the default, they are left out before they become rows; turn it off and every row says which is which in `carries_tag`. The match follows Facebook's own hashtag links, case and accents folded: `#PinalEsMágico` counted for `pinalesmagico` on platform run `ABvwN9Z58X1pfTW5X`. The scraper we compared on 21 November 2026 took one search query and a maximum, with no such filter; this one takes a list of hashtags in one run.

![How Facebook Hashtag Posts works: hashtags in, one row per public post out with its exact reactions, comments, shares and media](https://api.apify.com/v2/key-value-stores/RPT1LNaNbQoVImUE9/records/facebook-hashtag-posts-how-it-works-v1.png)

#### Copy to your AI assistant

```
feedminer/facebook-hashtag-posts on Apify. Collects the public Facebook posts listed under hashtags, anonymously: no Facebook account, no login, no cookies. It reads the hashtag page's Top and Latest tabs (facebook.com/hashtag/<tag>) and, on request, Facebook's post search for the tag, month by month. One dataset row per post per hashtag: within one hashtag a post is delivered once, from the walk that listed it first; a post listed under two of the hashtags sent is two rows, each naming its hashtag. Row: post_id, url (permalink), hashtag (normalised: no #, lower case), source (top|latest|search), position (its place in that walk in this run, not a rank), created_at, collected_at (ISO 8601 UTC), author_name, author_id, author_url, author_avatar (50-px square, signed address), text (the post's own message), hashtags[] (as Facebook parsed them), carries_tag (bool: the text carries the hashtag, case and accents folded), is_share (bool), reactions, reactions_by_type{like, love, care, haha, wow, sad, angry} (exact, all seven on every row), comments, shares, video_views (0 off a video), media_type (photo|video|link|none), media[{type, url, alt, title, thumbnail, hd_url, sd_url, duration_ms, width, height, captions[{locale, url}], dash_manifest (MPD XML), encodings[{kind (video|audio), quality, width, height, frame_rate, codecs, bitrate, sample_rate, encoding_tag, url}]}] (keys that do not apply to the media type are absent), input (the form entry as typed). Media and avatar addresses are signed and expire within days. Hashtags that gave nothing (no hashtag page, withheld from logged-out readers, no post carrying the tag, no posts, unreadable) are named in the run's status message, never as rows. Billing: one "post" event per delivered row, plus the $0.00005 Actor start; posts left out by onlyTagged are not billed. Call ApifyClient("TOKEN").actor("feedminer/facebook-hashtag-posts").call(run_input={"hashtags": ["gardening", "#BlackFriday"], "tabs": ["top", "latest"], "searchMonths": 1, "maxPostsPerHashtag": 300}), then client.dataset(run["defaultDatasetId"]).list_items().items. Inputs: hashtags (string[], required: tags with or without #, or facebook.com/hashtag/ links; case folded, duplicates read once). tabs (string[] of top, latest; default both; [] reads the search alone). searchMonths (integer 0-12, default 0 = search off). onlyTagged (bool, default true). maxPostsPerHashtag (integer 1-10000, default 1000, tabs and search together). debugMode (bool, default false). Full spec: GET https://api.apify.com/v2/acts/feedminer~facebook-hashtag-posts/builds/default (Bearer TOKEN) → inputSchema, actorDefinition.storages.dataset, readme. Token: https://console.apify.com/account/integrations
```

***

### How to scrape hashtag posts from Facebook

Paste the hashtags you follow, as you have them: `gardening`, `#Gardening` and `https://www.facebook.com/hashtag/gardening` are one hashtag, read once. The examples go from the cheapest run to the widest.

##### The form's prefill: three hashtags, both tabs

```json
{ "hashtags": ["gardening", "blackfriday", "pinalesmagico"] }
```

Everything else at its default: the Top and Latest tabs, no search, only the posts that carry the tag, up to 1 000 per hashtag. Platform run `DIR2peEd38HKagiVr` ran exactly this and delivered 328 posts in 88.3 seconds. The tabs end on their own, well below the default cap.

##### Hashtags as you copied them, on one tab

```json
{
  "hashtags": ["#BlackFriday", "https://www.facebook.com/hashtag/pinalesmagico", "fitness"],
  "tabs": ["top"]
}
```

The input of platform run `ABvwN9Z58X1pfTW5X`: 156 posts in 55.2 seconds. Its rows read `hashtag: "blackfriday"` and `hashtag: "pinalesmagico"`, and keep what you typed in `input`, so you can join them back to your own list. A hashtag Facebook withholds from readers who are not logged in, as it did `fitness` when this Actor was built, gives no row and is named in the run's closing sentence.

##### Add Facebook's post search, one month back

```json
{ "hashtags": ["gardening"], "searchMonths": 1, "maxPostsPerHashtag": 300 }
```

The search goes past what the hashtag page shows: everything it lists for the tag, its most recent posts, then the current calendar month and as many before it as you ask. Platform run `hWzM0amwC0bv5s7aJ` reached the cap of 300 in 487.2 seconds. The search is the slow part of a run, so a cap is the way to bound it.

##### Many hashtags, with the search on

```json
{
  "hashtags": ["marketing", "food", "photography", "music", "nature", "football", "christmas", "thanksgiving",
               "realestate", "wedding", "dogs", "books", "nba", "anime", "yoga", "startup"],
  "searchMonths": 1,
  "maxPostsPerHashtag": 250
}
```

The input of the stress run in the Performance table, `09a4Rekx2cWr5HGjr`: 2 282 posts in 638.0 seconds, ended SUCCEEDED. Eight hashtags are read at once.

### Input parameters

##### What to read

| Parameter | Type | Default | Description |
|---|---|---|---|
| `hashtags` | string\[] | `gardening`, `blackfriday`, `pinalesmagico` (prefill) | Required. The hashtags you want the public posts of: with or without `#`, in any case and any script, or a pasted `facebook.com/hashtag/` link. Facebook folds case, so `Travel` and `travel` are one hashtag, and duplicates are read once. Spaces are dropped, so `Black Friday` reads `blackfriday`; an entry holding a character a hashtag cannot, such as a hyphen, is skipped. |
| `tabs` | string\[] | `top`, `latest` | Which tabs of the hashtag page to read. Each tab ends on its own, and a post found in both is one row. Latest is Facebook's own selection, not a timeline: for fresh posts, turn on the search. Send `[]` to read the search alone. |
| `searchMonths` | integer | `0` | Adds Facebook's post search for the hashtag: everything it lists, its most recent posts, then one pass per calendar month for this many months back, the current one first. 0 to 12; 0 leaves the search off. |

##### What to keep

| Parameter | Type | Default | Description |
|---|---|---|---|
| `onlyTagged` | boolean | `true` | Keep only the posts whose own text carries the hashtag, as Facebook linked it, case and accents folded, so `#PinalEsMágico` counts for `pinalesmagico`. The search reads the hashtag as a keyword and lists many posts that do not carry it. Those are left out and never charged. Turn off to receive everything Facebook listed, each row saying in `carries_tag` whether it carries the hashtag. |
| `maxPostsPerHashtag` | integer | `1000` | The most rows one hashtag may deliver, tabs and search together. 1 to 10 000. The tabs end on their own well below the default; this is what bounds the search. |

##### Advanced

| Parameter | Type | Default | Description |
|---|---|---|---|
| `debugMode` | boolean | `false` | Verbose log lines for support. Leave off. |

For each hashtag the tabs are read first, in the order given, then the search's passes; a post a later pass lists again is skipped, so each post is one row per hashtag. `onlyTagged` decides what becomes a row, and `maxPostsPerHashtag` counts only the rows delivered. A form with no tab and `searchMonths` at 0, or a list with no usable hashtag, stops the run before it reads anything.

### What data can you extract from Facebook?

Every row is one public post under one of your hashtags, as Facebook served it to a reader who is not logged in. A column Facebook printed nothing for ships as its zero: an empty string, `0`, `false` or `[]`.

##### The post row

| Theme | Fields |
|---|---|
| Identity | `post_id`, `url` (the post's permalink, such as a `/posts/`, `permalink.php` or `/reel/` address) |
| Provenance | `hashtag` (as normalised: no `#`, lower case), `input` (the form entry it came from, as you typed it), `source` (`top`, `latest` or `search`: the walk that listed it first), `position` (where that walk listed it in this run, counting every post listed, kept or not, so it is not a rank), `collected_at` |
| Date | `created_at`, ISO 8601 in UTC, empty when the post carried no time |
| Author | `author_name`, `author_id`, `author_url` (profile or Page address), `author_avatar` (a 50-pixel square, 40 where only the post's header prints it) |
| Content | `text` (the post's own message, never a shared post's), `hashtags` (as Facebook parsed them in the message), `carries_tag`, `is_share` |
| Engagement | `reactions` (exact), `reactions_by_type` (`like`, `love`, `care`, `haha`, `wow`, `sad` and `angry`, exact, each present and 0 when nobody used it; a type Facebook adds would appear beside them under its numeric id), `comments`, `shares`, `video_views` (0 on a post that is not a video) |
| Media | `media_type` (the first attachment's type: `photo`, `video`, `link` or `none`), `media[]`, one entry per attachment, an album's photos one by one |

Each `media` entry carries the keys of its own type only:

| Type | Keys |
|---|---|
| Photo | `type`, `url` (the feed's rendition), `alt` (Facebook's description of the image), `width` and `height` (the photo's full size; `url` serves that size or smaller, in the same proportions) |
| Video | `type`, `url` (the video's page), `thumbnail`, `hd_url` and `sd_url` (direct MP4 files), `duration_ms`, `width`, `height`, `captions[]` as `{locale, url}` (SRT tracks), `dash_manifest` (the MPD document Facebook serves its own player), `encodings[]` (the manifest's streams one by one, as `{kind, quality, width, height, frame_rate, codecs, bitrate, sample_rate, encoding_tag, url}`, each a whole MP4) |
| Link | `type`, `url` (where it points), `title`, `thumbnail` |

A video inside an album comes with its page and a frame only: Facebook prints no file, size or manifest for it there. A video Facebook serves as an MP4 alone has no manifest.

![What one Facebook hashtag post row carries, field by field: the hashtag and walk that found it, carries_tag, reactions by type, and the video's MP4 and DASH streams](https://api.apify.com/v2/key-value-stores/RPT1LNaNbQoVImUE9/records/facebook-hashtag-posts-row-anatomy-v1.png)

On the 30 rows the platform runs of 21 November 2026 sampled, the first rows of each run's dataset and all from the Top tab, every row carried its date, author id, avatar, permalink, text and parsed hashtags, and 29 of 30 the author's profile address. The reaction types added up to the total on 30 of 30. The 27 photo rows held 56 photos, each with its description, width and height; the 3 video rows each carried both MP4 files, duration, size, frame, views and the DASH manifest. No link post, shared post or caption track was among those 30.

##### Example row

Wildlife Aid's reel under `#nature`, as platform run `W82WzsLBFvKjWiOEF` delivered it on 21 November 2026. The text is shortened, the addresses and the manifest are cut, and two of the video's nine streams are shown; the row carries them whole.

```json
{
  "post_id": "1067850712051800",
  "url": "https://www.facebook.com/reel/948421750457798/",
  "hashtag": "nature",
  "source": "top",
  "position": 2,
  "created_at": "2025-03-26T13:58:23Z",
  "collected_at": "2026-11-21T08:27:36Z",
  "author_name": "Wildlife Aid",
  "author_id": "100064806427826",
  "author_url": "https://www.facebook.com/WildlifeAid",
  "author_avatar": "https://scontent-lga3-3.xx.fbcdn.net/v/t39.30808-1/420000817_…",
  "text": "The tail wag at the end … Another day and another load of mouths to feed… but aren’t they so adorable. ...#wildlifeaidfoundation #wildlifeaid #wildlife … #nature #redfox #fox #babyanimal #instareel #cuteanimalvideos",
  "hashtags": ["wildlifeaidfoundation", "wildlifeaid", "wildlife", "wildliferescue", "wildliferehabilitation", "wildlifehospital", "animalreel", "foxcub", "foxcubs", "nature", "redfox", "fox", "babyanimal", "instareel", "cuteanimalvideos"],
  "carries_tag": true,
  "is_share": false,
  "reactions": 6641,
  "reactions_by_type": { "angry": 1, "care": 657, "haha": 6, "like": 4572, "love": 1403, "sad": 1, "wow": 1 },
  "comments": 126,
  "shares": 215,
  "video_views": 75770,
  "media_type": "video",
  "media": [
    {
      "type": "video",
      "url": "https://www.facebook.com/reel/948421750457798/",
      "thumbnail": "https://scontent-lga3-1.xx.fbcdn.net/v/t15.5256-10/486566762_…",
      "hd_url": "https://video-lga3-3.xx.fbcdn.net/o1/v/t2/f2/m266/AQPFjFSb4Yyd….mp4?…",
      "sd_url": "https://video-lga3-1.xx.fbcdn.net/o1/v/t2/f2/m412/AQN6HtgGkYAY….mp4?…",
      "duration_ms": 21000,
      "width": 1080,
      "height": 1920,
      "dash_manifest": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<MPD xmlns=\"urn:mpeg:dash:schema:mpd:2011\" … mediaPresentationDuration=\"PT21S\" …",
      "encodings": [
        { "kind": "video", "quality": "1080p", "width": 1080, "height": 1920, "frame_rate": 30, "codecs": "av01.0.08M.08.0.110.01.01.01.0", "bitrate": 1623311, "encoding_tag": "dash_r2av1-r1gen2vp9_q90", "url": "https://video-lga3-2.xx.fbcdn.net/o1/v/t2/f2/m366/…" },
        { "kind": "audio", "codecs": "mp4a.40.5", "bitrate": 79286, "sample_rate": 44100, "encoding_tag": "dash_ln_heaac_vbr3_audio", "url": "https://video-lga3-1.xx.fbcdn.net/o1/v/t2/f2/m412/…" }
      ]
    }
  ],
  "input": "nature"
}
```

#### How long do the photo and video links work?

Facebook signs every image and video address with an expiry. On the 30 rows the platform runs of 21 November 2026 sampled, the photo, frame and video addresses expired 104 to 108 hours after `collected_at`, except one video's HD file, 33 hours after it: the reel above. The avatars expired 104 to 719 hours after it. Download the files you want within a day of the run, or run again for fresh addresses; the counts on the rerun will be current too.

#### Why is the same post in my dataset twice?

Because two of your hashtags list it. A post is one row per hashtag, each row naming its own `hashtag`, so a dataset filtered by hashtag is complete on its own. Within one hashtag a post is never repeated, whichever tabs and search passes list it.

#### Why are video rows so much larger?

The manifest and its streams. On the rows sampled on 21 November 2026, photo rows weighed 1 791 to 5 652 bytes as JSON and video rows 23 526 and 26 214, of which the manifest alone was 12 008 and 13 642. In a CSV or Excel export the manifest lands in one long cell; JSON keeps it readable.

### What this Actor covers

![What Facebook Hashtag Posts reaches, and what it does not](https://api.apify.com/v2/key-value-stores/RPT1LNaNbQoVImUE9/records/facebook-hashtag-posts-coverage-v1.png)

It reads what Facebook serves to a visitor who is not logged in: a hashtag page's Top and Latest tabs, and Facebook's post search for the tag. It does not read comment text, the list of who reacted or shared, friends-only posts, private groups, or a hashtag Facebook keeps from logged-out readers. **No other FeedMiner Actor reads Facebook**, so nothing in the right-hand column is covered elsewhere in the suite.

**For the same hashtag on X**, [X Tweet Scraper](https://apify.com/feedminer/x-tweet-scraper) takes it as a search term and returns the tweets with every count, and [Telegram Channel Messages](https://apify.com/feedminer/telegram-channel-messages) reads every public post of a Telegram channel with its views and reactions.

### Pricing

| Plan | Price per 1 000 `post` events |
|---|---|
| Free | $2.69 |
| Bronze | $2.69 |
| Silver | $2.46 |
| Gold, Platinum, Diamond | $2.24 |

One `post` event is one delivered row: one post under one of your hashtags, from the tabs or the search alike. The only other charge is the platform's own Actor start, $0.00005 per run. A post listed under two of your hashtags is two rows, and two events.

You are charged for what reaches your dataset and for nothing else. Not billed:

- a post whose own text does not carry the hashtag, while `onlyTagged` is on, the default;
- the same post listed again under the same hashtag, by the other tab or a search pass;
- the posts past `maxPostsPerHashtag`;
- a hashtag that gives nothing: no hashtag page, withheld from readers who are not logged in, no post carrying the tag, no post at all, or not served on any exit tried, each named in the run's closing sentence;
- a row the dataset did not accept, or one lost when a run is killed: billing follows what the dataset took, not what was offered to it.

With `onlyTagged` off, every post Facebook listed is a row, and each one is billed, `carries_tag: false` included.

##### Against the market

We compared one other Facebook hashtag scraper on the Apify Store on 21 November 2026 (read at 05:00 UTC). It charged per dataset item, the same unit as a post here. Its prices then, per 1 000:

| Plan | This Actor | The other scraper compared |
|---|---|---|
| Free | $2.69 | $2.99 |
| Bronze | $2.69 | $2.99 |
| Silver | $2.46 | $2.99 |
| Gold, Platinum, Diamond | $2.24 | $2.99 |

Its Actor start was $0.09 per run, against $0.00005 here. Store prices move, so read these as of that date.

##### What a real run costs

The platform runs below were made on 21 November 2026, before the price was posted, so they billed nothing. This is what each would cost at the prices above.

| Run | What it did | Posts | Free plan | Gold |
|---|---|---|---|---|
| `DIR2peEd38HKagiVr` | the form's prefill: three hashtags, both tabs | 328 | $0.88 | $0.73 |
| `ABvwN9Z58X1pfTW5X` | `#BlackFriday`, a pasted `pinalesmagico` link and `fitness`, Top tab | 156 | $0.42 | $0.35 |
| `hWzM0amwC0bv5s7aJ` | `gardening`, both tabs and the search one month back, capped at 300 | 300 | $0.81 | $0.67 |
| `09a4Rekx2cWr5HGjr` | sixteen hashtags, both tabs and the search one month back, 250 each at most | 2 282 | $6.14 | $5.11 |

Each run also pays the $0.00005 start.

##### Free tier

Apify's free plan comes with monthly platform credits. The prefill run above, 328 posts, would use $0.88 of them, so you can see the output before committing to anything.

### Advanced usage

##### A campaign hashtag over the past year

```json
{
  "hashtags": ["blackfriday"],
  "searchMonths": 12,
  "maxPostsPerHashtag": 3000
}
```

Twelve calendar months of Facebook's post search on top of both tabs, each row labelled `top`, `latest` or `search` in `source`, and dated in `created_at` for your own time series. The platform runs so far searched one month back; a year has not been timed on the platform, and the search read 0.62 posts a second on one hashtag (`hWzM0amwC0bv5s7aJ`), so give such a run a long timeout.

##### A brand or topic set, read wide and cheap

```json
{
  "hashtags": ["gardening", "#GardenTips", "nativeplants", "homegarden", "backyardbirds"],
  "tabs": ["top", "latest"]
}
```

The tabs alone are the fast way to cover many hashtags: the prefill's three gave 328 posts in 88.3 seconds (`DIR2peEd38HKagiVr`). Each row names its `hashtag`, and a post under two of them comes once for each, so the overlap between your tags is visible in the data.

##### Everything Facebook lists, labelled

```json
{ "hashtags": ["gardening"], "onlyTagged": false }
```

For studying what Facebook itself surfaces under a hashtag, including posts whose text does not carry it. Each row says which it is in `carries_tag`, and each is billed. Every platform run so far kept `onlyTagged` on.

##### Counts over time, by scheduling the same input

```json
{ "hashtags": ["blackfriday", "thanksgiving"], "tabs": ["top"] }
```

Each run reads the counts of that moment and stamps them in `collected_at`; nothing is cached between runs. They move between reads: one `blackfriday` post read 314 reactions at 08:05:34 UTC and 315 at 08:07:11 the same morning (`DIR2peEd38HKagiVr`, `ABvwN9Z58X1pfTW5X`). Schedule the input daily and join the rows on `post_id`.

### Integrate Facebook data into your stack

Everything Apify offers applies: scheduled runs, webhooks on finish, and exports to S3, Google Sheets, Airtable or a database. The dataset is readable as JSON, CSV, Excel or XML from the API, and the Console shows it as a Posts table with the hashtag, date, author, text, counts, media type and link.

##### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("feedminer/facebook-hashtag-posts").call(run_input={
    "hashtags": ["gardening", "#BlackFriday"],
    "tabs": ["top", "latest"],
    "searchMonths": 1,
    "maxPostsPerHashtag": 300,
})

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["hashtag"], post["source"], post["author_name"], post["reactions"],
          post["reactions_by_type"]["love"], post["shares"], post["url"])
```

##### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('feedminer/facebook-hashtag-posts').call({
    hashtags: ['gardening', '#BlackFriday'],
    tabs: ['top', 'latest'],
    searchMonths: 1,
    maxPostsPerHashtag: 300,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const post of items) {
    console.log(post.hashtag, post.source, post.author_name, post.reactions,
        post.reactions_by_type.love, post.shares, post.url);
}
```

### Performance

| Measure | Value | Measured on |
|---|---|---|
| Posts per second, both tabs | 3.7 | run `DIR2peEd38HKagiVr`: 328 posts from `gardening`, `blackfriday` and `pinalesmagico` in 88.3 s |
| The Top tab alone | 2.8 a second | run `ABvwN9Z58X1pfTW5X`: 156 posts in 55.2 s from three entries, `fitness` among them |
| The search on, one hashtag | 0.62 a second | run `hWzM0amwC0bv5s7aJ`: 300 posts from `gardening`, the cap, in 487.2 s with the search one month back |
| The search on, sixteen hashtags | 3.6 a second | run `09a4Rekx2cWr5HGjr`: 2 282 posts in 638.0 s, 250 per hashtag at most |
| The same input, started alongside | 3.5 a second | run `ETCbsdwwddcqj67V4`: 2 233 posts in 634.7 s |
| Hashtags read at once | 8 | the code (`walk.go`) |
| Memory | 256 MB | all six platform runs in this table and below |
| Outcome | SUCCEEDED, 5 of 5 | every run not killed on purpose: the five above |
| Rows kept when a run is killed | 430 in the dataset | run `W82WzsLBFvKjWiOEF`, aborted 36.9 s in |
| Facebook accounts used | none | every run |

The clock moves more than the input does. The same inputs ran three times on 21 November 2026, the first two times on earlier builds: the prefill took 79.8, 229.4 and 88.3 seconds (`xAWEkLirbmQRKEpve`, `R996ReLgSs4FaJ501`, `DIR2peEd38HKagiVr`), and the one-hashtag search 358.1, 328.1 and 487.2 seconds (`d8pGQxfPS8RVqTQw2`, `c2dfQKnxOuUAHVee3`, `hWzM0amwC0bv5s7aJ`). The stress run's sixteen hashtags could have given 4 000 posts at 250 each and gave 2 282: a hashtag stops at its cap, where Facebook stops listing, at a walk's backstop, or on a page Facebook would not serve, and the run's closing sentence counts the hashtags a refused page, a tab's backstop or the time limit cut short. A tab still going after 60 pages is cut and reported, which means Facebook changed the page; a search pass stops after 100 pages, or after ten pages in a row that kept no post. What the platform runs have not measured yet: the search more than one month back, the search alone, `onlyTagged` off, and the tabs alone over more than three hashtags.

Rows are written to the dataset as they are read: a batch goes out when 1 000 rows are waiting, or 30 seconds after the last write, in requests of at most 5 MB. A run that is killed keeps every batch already written, and can lose what was read since the last one; you are not charged for those, because billing follows what the dataset accepted. A run that reaches its timeout is built to stop reading 30 seconds before it, deliver what it has and end SUCCEEDED with a sentence saying which hashtags it left short; no platform run has reached its timeout on this build yet.

### FAQ

**Do I need a Facebook account, a login or cookies?**
No. Every read is a request Facebook's own hashtag page and post search make for a visitor who is not logged in. No account of yours is involved, and none of ours either.

**How many posts can I get per hashtag?**
The tabs end on their own: both tabs of the prefill's three hashtags gave 328 posts on platform run `DIR2peEd38HKagiVr`. The search adds to that, one calendar month at a time, up to twelve; with one month, `gardening` reached its cap of 300 (`hWzM0amwC0bv5s7aJ`). `maxPostsPerHashtag` allows up to 10 000. Facebook lists a selection of a hashtag's posts, not every post ever tagged.

**Is the Latest tab the newest posts?**
No. Latest is Facebook's own selection, not a timeline. For the newest posts, turn the search on: its second pass is Facebook's most recent posts for the tag, and each month after that is a window of its own.

**A hashtag I sent came back with nothing.**
The run's closing sentence, shown as its status on the Console, names it and says why: Facebook has no hashtag page by that name, withholds the hashtag from readers who are not logged in, listed no post that carries it in its text, listed nothing at all, or would not serve it on any exit tried. None of it is billed. With the search on, a hashtag withheld from its own page is still searched.

**Why did I get fewer posts than Facebook shows under the hashtag?**
`onlyTagged` is on by default and leaves out the posts whose text does not carry the hashtag; the closing sentence counts them. A post listed by both tabs and the search is also one row, not three.

**Is the data live?**
Yes. Every run reads Facebook at that moment, and `collected_at` is on every row. Reactions, comments, shares and views are those of the read; nothing is cached or resold.

**The image or video links in my rows stopped working.**
They expired. Facebook signs each address for a limited time: about four and a half days on the rows measured, and 33 hours for one HD file. Run again for fresh addresses.

**My run reached its time limit.**
It is built to stop reading 30 seconds before the timeout and end SUCCEEDED with what it read, its closing sentence naming the hashtags it left short. Give the run a longer timeout, or ask for fewer hashtags, search months or posts per hashtag.

**What does it not do?**
It does not read comment text, the list of who reacted or shared, friends-only posts, private groups, or anything behind a login. It does not download the files themselves: it gives their addresses. It keeps no history: every count is Facebook's at the moment of the run.

***

### Support

- Found something off in the output, or need a field that is missing? Open the **Issues** tab on this Actor's page with the input you ran and what you expected. Issues are read daily.
- Need a custom variant, such as another filter, a column this one does not carry, or another Facebook surface? Ask in the Issues tab; FeedMiner builds on request.

### Legal compliance

This Actor collects only public data, the same posts and counts any visitor sees on Facebook without logging in. Author names, profile addresses, avatars and the people who appear in posts can be personal data: processing information about people in the EU, the UK or California requires a lawful basis under GDPR or CCPA. Photos, videos and texts remain their authors' works, so storing or republishing them needs the rights to do so. Use the data for social listening, campaign and market research, and content analysis you are entitled to, not for harassment, for re-uploading other people's content, or for building profiles of private individuals.

***

**FeedMiner** · Fast, honestly priced scrapers, kept alive when platforms change.

Facebook Hashtag Posts · [X Tweet Scraper](https://apify.com/feedminer/x-tweet-scraper) · [All FeedMiner Actors](https://apify.com/feedminer)

# Actor input Schema

## `hashtags` (type: `array`):

The hashtags you want the public posts of. With or without #, in any case and any script, or a pasted facebook.com/hashtag/ link — Facebook folds case, so Travel and travel are one hashtag, and duplicates are read once. A hashtag Facebook has no page for, or withholds from readers who are not logged in, yields no rows and is named in the run's closing line with the reason.

## `tabs` (type: `array`):

Which tabs of the hashtag page to read: Top, Latest, or both. Each tab ends on its own after about 65 to 100 posts, so both together give about 120 to 155 posts a hashtag, a post found in both being one row. Latest is Facebook's own selection and not a timeline: for fresh posts, turn on the search below. Leave both off to read the search alone.

## `searchMonths` (type: `integer`):

Adds Facebook's post search for the hashtag beyond its page: everything the search lists, its most recent posts, then one pass per calendar month for this many months back, the current one first. It adds tens to hundreds of posts a hashtag, more with each month, and reads about one page of five posts every two seconds, so a run takes longer. 0 leaves it off.

## `onlyTagged` (type: `boolean`):

Keep only the posts whose own text carries the hashtag, as Facebook itself linked it — case and accents folded, so #PinalEsMágico counts for pinalesmagico. Facebook also lists posts that do not: about a quarter of a hashtag page, and more of the search, which reads the hashtag as a keyword. Those are left out and never charged. Turn off to receive everything Facebook listed, each row saying whether it carries the hashtag.

## `maxPostsPerHashtag` (type: `integer`):

The most rows one hashtag may deliver, tabs and search together. The tabs end on their own well below the default; this bounds the search.

## `debugMode` (type: `boolean`):

Verbose log lines for support. Leave off.

## Actor input object example

```json
{
  "hashtags": [
    "gardening",
    "blackfriday",
    "pinalesmagico"
  ],
  "tabs": [
    "top",
    "latest"
  ],
  "searchMonths": 0,
  "onlyTagged": true,
  "maxPostsPerHashtag": 1000,
  "debugMode": false
}
```

# Actor output Schema

## `posts` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "hashtags": [
        "gardening",
        "blackfriday",
        "pinalesmagico"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("feedminer/facebook-hashtag-posts").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "hashtags": [
        "gardening",
        "blackfriday",
        "pinalesmagico",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("feedminer/facebook-hashtag-posts").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "hashtags": [
    "gardening",
    "blackfriday",
    "pinalesmagico"
  ]
}' |
apify call feedminer/facebook-hashtag-posts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,feedminer/facebook-hashtag-posts"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/eFW21f6AoOmzfwj2W/builds/RXkQ4IUc8dyTif4Zk/openapi.json
