# Bluesky Posts Scraper: Posts, Likes, Reposts & Monitor (`webobsidians/bluesky-posts-scraper`) Actor

Scrape the posts of any Bluesky account without a login or API key: text, date, likes, reposts, replies, quotes, hashtags, links, images and video. Filter by date, add replies or reposts, and use the built-in monitor to get only new posts.

- **URL**: https://apify.com/webobsidians/bluesky-posts-scraper.md
- **Developed by:** [Web Obsidians](https://apify.com/webobsidians) (community)
- **Categories:** Social media, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## Bluesky Posts Scraper

Get the posts of **any public Bluesky account** in one clean format: text, date, likes, reposts, replies, quotes, bookmarks, hashtags, mentions, links, images, video and quoted posts. Paste handles or profile links, optionally add replies or reposts, set a date range, and download the result.

Turn on **Return only new posts** and schedule the Actor to monitor accounts: each run returns only the posts that appeared since the last run.

### Why this Actor

- **No login, no API key.** It reads Bluesky's public API, the same data anyone can see without an account. No browser, no proxies.
- **The numbers that matter.** Likes, reposts, replies, quotes and bookmarks come with every post, together with the author, language, hashtags, mentions and links.
- **Media included.** Image links (full size and thumbnail, with their alt text), video playlists, link cards and the link of a quoted post.
- **Your choice of posts.** Only the account's own posts by default; turn on replies, reposts, or keep only posts with images or video.
- **Monitoring built in.** The monitor remembers the newest post it returned and gives you only newer posts on the next run, oldest first.
- **Respects privacy settings.** Accounts that ask apps not to show them to logged-out people are skipped and cost nothing.
- **Cheap and predictable.** $1.00 per 1,000 posts, plus $0.00005 per run start. Platform usage is included.

### Use cases

- **Social listening and brand monitoring:** follow companies, journalists or creators and send each new post to Slack or a webhook.
- **Research and analysis:** collect posts with their engagement numbers for a set of accounts and compare them over time.
- **Content and competitor tracking:** see which posts of an account get the most likes, reposts and quotes.
- **AI agents and RAG:** give your agent the clean text of posts with their dates, links and authors.

### How to use

1. Add accounts to **Accounts**, one per line: `bsky.app`, `@jay.bsky.team`, `https://bsky.app/profile/bsky.app` or a DID such as `did:plc:z72i7hdynmk6r22z27h6tvur`. A name without a dot is read as `name.bsky.social`.
2. Optionally set how many posts you want per account, a date range, replies, reposts or media only.
3. Click **Start**. Download the results as JSON, CSV or Excel, or send them on with Apify integrations and webhooks (for example to Slack).

#### Input example

This is the input of a real run of this Actor:

```json
{
  "accounts": ["bsky.app", "jay.bsky.team"],
  "maxPostsPerAccount": 20
}
```

#### Get only new posts every hour

Set **Return only new posts** to on and give the monitor a name (for example `brand-watch`). Then create a schedule in Apify Console. The first run returns the latest posts and remembers where it stopped. Each later run returns only posts that are newer than the last post it returned, oldest first. If a run could not return everything (your per-account limit or your maximum cost per run was reached), the rest is returned by the next run. You pay only for the posts that are returned.

### Output

Each post is one item in the dataset. This is a real item from a run of this Actor, shortened (the image links are cut):

```json
{
  "account": "bsky.app",
  "postId": "3n2m24be4e223",
  "url": "https://bsky.app/profile/bsky.app/post/3n2m24be4e223",
  "date": "2026-11-18T17:05:26Z",
  "text": "Encrypted DMs from your Bluesky profile—now for Android and iOS!\n\nOur friends at Germ have built end-to-end encrypted messaging, including voice notes, on the same open protocol as Bluesky. Log in to Germ with your Bluesky account for fully private DMs.\n\nTry it: @germnetwork.com",
  "authorHandle": "bsky.app",
  "authorName": "Bluesky",
  "likes": 2380,
  "reposts": 500,
  "replies": 133,
  "quotes": 139,
  "bookmarks": 506,
  "langs": ["en"],
  "isReply": false,
  "replyTo": null,
  "isRepost": false,
  "repostedAt": null,
  "hashtags": [],
  "mentions": ["germnetwork.com"],
  "links": [],
  "images": [
    {
      "url": "https://cdn.bsky.app/img/feed_fullsize/plain/…",
      "thumbnail": "https://cdn.bsky.app/img/feed_thumbnail/plain/…",
      "alt": "Graphic showing the Germ DM button at the top of a Bluesky profile."
    }
  ],
  "video": null,
  "externalLink": null,
  "quotedPost": null,
  "labels": [],
  "uri": "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3n2m24be4e223",
  "authorDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "scrapedAt": "2026-11-20T03:39:04Z"
}
```

Field notes:

- `account` is the handle of the account you asked for. For a repost, `authorHandle` and `authorName` are the original author, and `repostedAt` is when the account reposted it.
- `date`, `repostedAt` and `scrapedAt` are UTC. `date` is the time the post was written.
- `likes`, `reposts`, `replies`, `quotes` and `bookmarks` are whole numbers at the moment of the run.
- `mentions` are handles, `hashtags` are tags without `#`, `links` are the links inside the text. A link card is in `externalLink`, a quoted post in `quotedPost` (its link), images in `images` and a video in `video` (`playlist` is an HLS link).
- `isReply` is true for a reply; `replyTo` is the link of the post it answers.
- `labels` are the moderation labels Bluesky shows on the post, if any.
- A per-account summary (display name, followers, following, number of posts, posts returned and any error) is saved to the key-value store as `SUMMARY`.

### Pricing

This Actor uses pay-per-event pricing:

- **$1.00 per 1,000 posts** saved to the dataset ($0.001 per post).
- **$0.00005 per run start.**

Platform usage (compute and storage) is included. For example, 100 posts cost about $0.10, and an hourly monitor of an account that writes 5 posts a day costs about $0.19 a month ($0.15 for 150 posts plus $0.04 for 720 run starts). If you set a maximum cost per run, the Actor stops cleanly when it is reached.

### FAQ

**Which accounts work?**
Any public Bluesky account: a `bsky.social` handle, a custom domain handle such as `jay.bsky.team`, or a DID. An account that does not exist is reported in `SUMMARY` with an error and costs nothing.

**Do I need a Bluesky account or an app password?**
No. The Actor reads Bluesky's public API, which works without logging in.

**Can it search all of Bluesky for a word?**
No. Bluesky's search needs a logged-in account, so this Actor works with accounts you name. Add the accounts you want to follow, and use the date range to narrow the results.

**What does it not get?**
Lists of followers or likers, direct messages, and accounts that ask apps not to show them to logged-out people (they are skipped and reported in `SUMMARY`).

**How many posts can I get?**
Up to 10,000 posts per account in one run, newest first. Bluesky gives 100 posts per request and the Actor pauses briefly between requests, so a large run takes a few minutes.

**How does the date range work?**
`dateFrom` and `dateTo` are UTC days (for example `2026-11-01`) and both days are included. The Actor reads from the newest post backwards and stops when it reaches `dateFrom`. For a repost the range looks at the day of the repost.

**How does the monitor know what is new?**
It remembers the newest post it returned for each account and returns posts that came after it. Each monitor run looks through the 2,000 newest posts of the account, so run it more often for a very busy account.

# Actor input Schema

## `accounts` (type: `array`):

One Bluesky account per line: a handle (bsky.app), @handle, a profile link (https://bsky.app/profile/bsky.app) or a DID (did:plc:...). A name without a dot is read as name.bsky.social.

## `maxPostsPerAccount` (type: `integer`):

Stop after this many posts per account, newest first. 0 means no limit, but at most 10,000 posts per account are returned in one run.

## `includeReplies` (type: `boolean`):

Also return the account's replies to other posts. Off: only the account's own top-level posts.

## `includeReposts` (type: `boolean`):

Also return the posts the account reposted (marked with isRepost and repostedAt). For a repost the date range looks at the day of the repost.

## `onlyWithMedia` (type: `boolean`):

Return only posts that have images or a video.

## `dateFrom` (type: `string`):

Skip posts older than this day. Format YYYY-MM-DD, UTC, for example 2026-11-01.

## `dateTo` (type: `string`):

Skip posts newer than this day (this day is included). Format YYYY-MM-DD, UTC.

## `onlyNewPosts` (type: `boolean`):

Return only posts that are newer than the ones returned by earlier runs with the same monitor name. The first run returns the latest posts and remembers where it stopped.

## `monitorName` (type: `string`):

Use different names to keep separate histories, for example one per client or per topic.

## Actor input object example

```json
{
  "accounts": [
    "bsky.app",
    "jay.bsky.team"
  ],
  "maxPostsPerAccount": 20,
  "includeReplies": false,
  "includeReposts": false,
  "onlyWithMedia": false,
  "onlyNewPosts": false,
  "monitorName": "default"
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "accounts": [
        "bsky.app",
        "jay.bsky.team"
    ],
    "maxPostsPerAccount": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("webobsidians/bluesky-posts-scraper").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 = {
    "accounts": [
        "bsky.app",
        "jay.bsky.team",
    ],
    "maxPostsPerAccount": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("webobsidians/bluesky-posts-scraper").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 '{
  "accounts": [
    "bsky.app",
    "jay.bsky.team"
  ],
  "maxPostsPerAccount": 20
}' |
apify call webobsidians/bluesky-posts-scraper --silent --output-dataset

```

## MCP server setup

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

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/AZ4ezXhpZKV51janw/builds/a4GOa7Pmf94RLJH2r/openapi.json
