# Bluesky Data Suite — Posts, Profiles, Followers (`leohryndev/bluesky-data-suite`) Actor

All-in-one Bluesky scraper on the official AT Protocol API: search posts and people, author feeds, follower exports, full reply threads, likes/reposts/quotes. Fast and stable with no browser or proxies — pay only $1 per 1,000 results.

- **URL**: https://apify.com/leohryndev/bluesky-data-suite.md
- **Developed by:** [Leo Hryn](https://apify.com/leohryndev) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 result items

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Bluesky Data Suite — Posts, Profiles, Followers & Engagement Scraper

All-in-one **Bluesky scraper** built directly on the official AT Protocol API. No browser emulation, no proxies, no fragile HTML parsing — which makes it **fast, stable, and one of the cheapest Bluesky scrapers on Apify** ($1 per 1,000 results, charged only for what you actually get).

### What you can collect

| Action | What you get | Login needed? |
|---|---|---|
| **Search posts** | Posts matching keywords, with sort (latest/top), language, and date filters | Free app password |
| **Search profiles** | People/accounts matching keywords (bios, follower counts) | No |
| **Profile details** | Full profile info for any list of handles (bulk) | No |
| **Author feeds** | All posts from any profiles (with/without replies, media-only option) | No |
| **Followers / Following** | Complete follower or following lists of any profiles | No |
| **Post replies** | Entire reply threads of any posts (with depth) | No |
| **Post engagement** | Everyone who liked, reposted, or quoted any posts | No |
| **Trending topics** | What's trending on Bluesky right now: topic, category, post count, hot status | No |
| **List members** | Full member exports of any Bluesky lists | No |
| **Starter pack members** | Everyone included in any starter packs (great topical seed lists) | No |

Inputs are flexible: pass handles (`name.bsky.social`), profile URLs, post URLs, list URLs, starter pack URLs, or AT-URIs — the Actor figures it out.

### Output

Clean, flat, analytics-ready rows. Posts include: text, timestamps, language, author (handle/DID/display name/avatar), like/repost/reply/quote counts, hashtags, mentions, links, image URLs + alt text, external link cards, quoted posts, and the web URL of every post. Profiles include: handle, DID, display name, bio, follower/following/post counts, and creation date.

```json
{
    "kind": "post",
    "url": "https://bsky.app/profile/example.bsky.social/post/3l6oveex3ii2l",
    "text": "We're excited to announce...",
    "createdAt": "2026-06-11T16:07:06.634Z",
    "authorHandle": "example.bsky.social",
    "authorDisplayName": "Example",
    "likeCount": 1420, "repostCount": 210, "replyCount": 88, "quoteCount": 19,
    "hashtags": ["ai"], "links": ["https://example.com"],
    "images": [{ "url": "https://cdn.bsky.app/...", "alt": "screenshot" }]
}
````

### Common use cases

- **Social listening & brand monitoring** — track keywords/mentions as Bluesky keeps growing.
- **Influencer research** — find accounts by topic, rank by followers, export author feeds to gauge engagement.
- **Audience export** — pull follower lists of any account in your niche (great seed lists for outreach or lookalike analysis).
- **Engagement mining** — who liked/reposted a viral post = a warm, topic-qualified audience.
- **Thread analysis** — full reply trees for sentiment/community research.
- **Datasets for AI** — clean JSON posts by topic, language, and date range.

### Why this one (honest comparison)

- **Official API, not HTML scraping** → doesn't break when Bluesky changes its UI.
- **No browser, no proxies** → starts in seconds, runs are cheap and fast.
- **$1.00 / 1,000 results** — pay-per-result; a failed or empty run costs you nothing.
- **10 actions in one Actor** → one integration instead of six different scrapers.

**About post search:** Bluesky gates its keyword-search endpoint behind a login. Create a **free app password** (bsky.app → Settings → Privacy and Security → App Passwords), pass it in the input, and post search works — the credential is used only for the search calls and never stored. Every other action works with no login at all.

### Scheduling & integrations

- **Schedules** — run it hourly/daily from Apify Console for continuous monitoring.
- **API / SDKs** — trigger runs from JavaScript, Python, or plain HTTP.
- **n8n / Make / Zapier** — pipe new posts or followers into Slack, Sheets, Airtable, your CRM.
- **MCP / AI agents** — usable as an MCP tool: let your Claude/agent search Bluesky people, pull threads, or export audiences on demand.

### FAQ

**Is this allowed?** Yes — it reads public data through Bluesky's own public API endpoints, the same data anyone sees without an account. No private data, no login walls bypassed.

**Rate limits?** The Actor honors Bluesky's rate-limit headers automatically with backoff, so runs complete reliably even for large exports.

**Charged for empty results?** No. Pay-per-result means exactly that — 0 results = $0.

**Does Bluesky have a public API?** Yes — the AT Protocol AppView API, and it's exactly what this Actor uses. That's the structural advantage over browser-based scrapers: official endpoints, stable fields, no anti-bot arms race.

**How do I export Bluesky followers to CSV or Google Sheets?** Choose the *Followers* action, paste profile handles or URLs, run, and use the dataset's one-click CSV/Excel export or the Apify → Google Sheets integration. Works for any public account, no login.

**Can I build a Bluesky monitoring dashboard?** Yes — schedule *Search posts* (or author feeds) hourly, pipe the dataset to Google Sheets/Looker Studio or via n8n to your BI tool. Each row is timestamped and flat, so charting engagement over time is trivial.

***

*More data tools from this developer: [apify.com/leohryndev](https://apify.com/leohryndev) — Telegram channel scraper, job-postings & hiring-signals data, AI-search brand monitoring.*

*Keywords: Bluesky scraper, Bluesky API, scrape Bluesky posts, Bluesky followers export, Bluesky search, AT Protocol, Bluesky data extraction, social listening Bluesky, Bluesky analytics, bsky scraper.*

# Actor input Schema

## `action` (type: `string`):

The type of data to collect from Bluesky.

## `queries` (type: `array`):

Depending on the action: search keywords (searchPosts, searchProfiles), profile handles or bsky.app profile URLs (getProfiles, getAuthorFeed, getFollowers, getFollowing), post URLs (getPostReplies, getPostEngagement), list URLs (getListMembers), or starter pack URLs (getStarterPackMembers). Not needed for trending topics.

## `maxItems` (type: `integer`):

Maximum number of result rows across all queries. You are only charged for results actually returned.

## `sort` (type: `string`):

Sorting for post search results.

## `language` (type: `string`):

Optional BCP-47 language code to filter posts, e.g. `en`, `es`, `de`, `ja`.

## `since` (type: `string`):

Optional ISO date(time) lower bound, e.g. `2026-01-01` — only posts after this moment.

## `until` (type: `string`):

Optional ISO date(time) upper bound.

## `authorFeedFilter` (type: `string`):

Which posts to include when collecting author feeds.

## `blueskyIdentifier` (type: `string`):

Only needed for 'Search posts by keyword': your Bluesky handle (e.g. `you.bsky.social`). Bluesky requires a logged-in session for post search. Create a FREE app password at Settings → Privacy and Security → App Passwords — never use your main password.

## `blueskyAppPassword` (type: `string`):

App password in the form xxxx-xxxx-xxxx-xxxx. Used only to call the official search endpoint; not stored anywhere.

## Actor input object example

```json
{
  "action": "searchProfiles",
  "queries": [
    "ai agents"
  ],
  "maxItems": 200,
  "sort": "latest",
  "authorFeedFilter": "posts_no_replies"
}
```

# 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 = {
    "queries": [
        "ai agents"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leohryndev/bluesky-data-suite").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 = { "queries": ["ai agents"] }

# Run the Actor and wait for it to finish
run = client.actor("leohryndev/bluesky-data-suite").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "ai agents"
  ]
}' |
apify call leohryndev/bluesky-data-suite --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=leohryndev/bluesky-data-suite",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Data Suite — Posts, Profiles, Followers",
        "description": "All-in-one Bluesky scraper on the official AT Protocol API: search posts and people, author feeds, follower exports, full reply threads, likes/reposts/quotes. Fast and stable with no browser or proxies — pay only $1 per 1,000 results.",
        "version": "1.0",
        "x-build-id": "eQb4MamTjfvBy2ZQU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leohryndev~bluesky-data-suite/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leohryndev-bluesky-data-suite",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/leohryndev~bluesky-data-suite/runs": {
            "post": {
                "operationId": "runs-sync-leohryndev-bluesky-data-suite",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/leohryndev~bluesky-data-suite/run-sync": {
            "post": {
                "operationId": "run-sync-leohryndev-bluesky-data-suite",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "What to collect",
                        "enum": [
                            "searchPosts",
                            "searchProfiles",
                            "getProfiles",
                            "getAuthorFeed",
                            "getFollowers",
                            "getFollowing",
                            "getPostReplies",
                            "getPostEngagement",
                            "getTrendingTopics",
                            "getListMembers",
                            "getStarterPackMembers"
                        ],
                        "type": "string",
                        "description": "The type of data to collect from Bluesky.",
                        "default": "searchProfiles"
                    },
                    "queries": {
                        "title": "Queries / handles / URLs",
                        "type": "array",
                        "description": "Depending on the action: search keywords (searchPosts, searchProfiles), profile handles or bsky.app profile URLs (getProfiles, getAuthorFeed, getFollowers, getFollowing), post URLs (getPostReplies, getPostEngagement), list URLs (getListMembers), or starter pack URLs (getStarterPackMembers). Not needed for trending topics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results (total)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of result rows across all queries. You are only charged for results actually returned.",
                        "default": 200
                    },
                    "sort": {
                        "title": "Sort (post search)",
                        "enum": [
                            "latest",
                            "top"
                        ],
                        "type": "string",
                        "description": "Sorting for post search results.",
                        "default": "latest"
                    },
                    "language": {
                        "title": "Language filter (post search)",
                        "type": "string",
                        "description": "Optional BCP-47 language code to filter posts, e.g. `en`, `es`, `de`, `ja`."
                    },
                    "since": {
                        "title": "Since (post search)",
                        "type": "string",
                        "description": "Optional ISO date(time) lower bound, e.g. `2026-01-01` — only posts after this moment."
                    },
                    "until": {
                        "title": "Until (post search)",
                        "type": "string",
                        "description": "Optional ISO date(time) upper bound."
                    },
                    "authorFeedFilter": {
                        "title": "Author feed filter",
                        "enum": [
                            "posts_no_replies",
                            "posts_with_replies",
                            "posts_and_author_threads",
                            "posts_with_media"
                        ],
                        "type": "string",
                        "description": "Which posts to include when collecting author feeds.",
                        "default": "posts_no_replies"
                    },
                    "blueskyIdentifier": {
                        "title": "Bluesky handle (only for post search)",
                        "type": "string",
                        "description": "Only needed for 'Search posts by keyword': your Bluesky handle (e.g. `you.bsky.social`). Bluesky requires a logged-in session for post search. Create a FREE app password at Settings → Privacy and Security → App Passwords — never use your main password."
                    },
                    "blueskyAppPassword": {
                        "title": "Bluesky app password (only for post search)",
                        "type": "string",
                        "description": "App password in the form xxxx-xxxx-xxxx-xxxx. Used only to call the official search endpoint; not stored anywhere."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```