# Bluesky Followers Scraper & Tracker: Export Followers List (`s_actors/bluesky-followers-scraper`) Actor

Export Bluesky followers and following lists without login, with each account's follower, following and post counts, bio email and follow time. Also who liked or reposted a post, list and starter pack members, people search. Track new followers, unfollowers and follower count over time.

- **URL**: https://apify.com/s_actors/bluesky-followers-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** Social media, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.34 / 1,000 accounts

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

### Bluesky Followers Scraper & Tracker: Export Followers List

Export the **followers and following list** of any Bluesky account to CSV, Excel or JSON, with **every account's follower, following and post counts**, verification, bio, join date, **email and website from the bio**, and **when each follow happened**. The same for the people who **liked or reposted a post**, the members of **lists and starter packs**, and a **people search** by name or bio. Schedule it as a **Bluesky follower tracker**: only **new followers**, **unfollowers**, and the **follower count over time** in a free profiles table.

```json
{ "profiles": ["nytimes.com"], "lists": "both", "maxPerInput": 0 }
```

No Bluesky account, app password or login needed. Use it as a **Bluesky followers API**: one call returns clean JSON, 100 accounts per request. `0` = the whole list, newest follow first.

#### What you get

One row per account. Real example, October 2026 (the most-followed accounts that @nytimes.com follows):

| handle | displayName | followersCount | followsCount | postsCount | isVerified | inputType | sourceHandle |
|---|---|---|---|---|---|---|---|
| theathletic.com | The Athletic | 392,694 | 318 | 17,297 | false | following | nytimes.com |
| rmac.bsky.social | Ryan Mac 🙃 | 237,745 | 1,577 | 3,805 | true | following | nytimes.com |
| kateconger.com | kate conger | 199,606 | 653 | 2,087 | true | following | nytimes.com |
| peterbakernyt.bsky.social | Peter Baker | 183,864 | 280 | 2,183 | true | following | nytimes.com |

| Field | Description |
|---|---|
| `handle`, `displayName`, `did`, `profileUrl`, `description`, `avatar`, `banner`, `createdAt` | The account, its bio and when it joined Bluesky |
| `followersCount`, `followsCount`, `postsCount` | Exact followers, following and posts of the account |
| `isVerified`, `isLabeler`, `labels`, `pinnedPostUrl` | Bluesky's blue check, moderation services, moderation labels (e.g. `spam`), the pinned post |
| `feedsCount`, `listsCount`, `starterPacksCount` | Custom feeds, lists and starter packs the account made |
| `email`, `emails`, `website`, `handleDomain`, `linkInBio`, `instagram`, `youtube`, `x`, `linkedin`, `telegram`, `twitch` | Contacts written in the bio; `handleDomain` = the account's own domain (nytimes.com) |
| `followedAfter`, `followedBefore` | Followers and following: the time window of the follow (one page of 100, usually minutes to hours on big accounts) |
| `followedAt` | The exact follow time, with **Exact follow time** on |
| `likedAt`, `addedAt` | Likes: when the account liked the post. Lists and starter packs: when it was added |
| `change` | Tracking runs: `new`, `unfollowed` (or `unliked`, `removed`) |
| `inputType`, `sourceHandle`, `sourceName`, `sourceUrl`, `sourceDid`, `sourceTotal`, `position` | Which list the row came from: `followers`, `following`, `likes`, `reposts`, `list`, `starterPack` or `search`; the list's owner, its size on Bluesky and the account's place in it (1 = newest) |
| `input`, `scrapedAt` | What you entered and when the run read it |

The dataset has three views: **Accounts**, **Contacts (email, website)** and **Follow times & changes**.

**Profiles table** (run's **Output** tab → *Profiles (CSV)*, also as JSON: key-value store records `profiles.csv` and `PROFILES`), one row per profile you entered, free:

| Column | Description |
|---|---|
| `handle`, `displayName`, `followersCount`, `followsCount`, `postsCount`, `isVerified`, `description`, contacts | The profile now |
| `previousCheckAt`, `previousFollowersCount`, `followersChange`, `followersChangePerDay`, `previousFollowsCount`, `followsChange` | Compared with the previous run of your account for this profile (any options) |
| `newFollowers`, `unfollowers`, `newFollowing`, `unfollowed` | With tracking on: how many followed and unfollowed since the previous run |
| `followersScraped`, `followingScraped` | Rows this run output |
| `followersHistory` | JSON only: every check with its time, followers, following and posts (up to 400 checks): the **follower count over time** |
| `error` | Why a profile failed (not found) |

#### How it works

1. Add **profiles**, **post links**, **list or starter pack links** and/or **people searches** (any mix)
2. Choose the **List** (followers, following or both), set **Max accounts per list** (`0` = all) and optional filters
3. Run, then download the dataset as CSV, Excel, JSON or HTML

| Input | What it does |
|---|---|
| **Profiles** | `name.bsky.social`, a custom-domain handle (`nytimes.com`), `@handle`, a bsky.app link or a DID |
| **List** | Followers, following (the accounts they follow) or both |
| **Post links** + **Post list** | The accounts that liked the post, reposted it, or both |
| **Lists and starter packs** | `bsky.app/profile/<handle>/lists/<id>`, `bsky.app/starter-pack/<handle>/<id>` or a `go.bsky.app` share link: every member |
| **Search people** | Words matched against names, handles and bios, as in the Bluesky search; up to 10,000 accounts per search |
| **Max accounts per list** | Default 1,000, `0` = the whole list |
| **Follower and post counts of each account** | On by default (one extra light request per 25 accounts); off = only what the list shows |
| **Exact follow time** | One request per account for `followedAt`; off = every row still has its time window |
| **Minimum / Maximum followers, Verified only, Only with an email, Bio keywords** | Filters: accounts that do not match are skipped and not charged |
| **Only new followers since the previous run**, **Unfollowers** | Tracking for scheduled runs, see below |

With filters and a limit, the Actor reads up to 20 times your limit (at least the 10,000 newest accounts) to find matches; set **Max accounts** to `0` to search the whole list. A missing profile, post or list is reported in the run status and not charged. Accounts that asked apps not to show them to logged-out people (Bluesky's `!no-unauthenticated` setting, about one in ten) are left out and not charged; the run status says how many.

#### Why this Actor

| | |
|---|---|
| 📊 **Counts in every row, no add-on** | Followers, following and posts of each account at the base price, so you can sort a follower list by reach |
| ⏱️ **When they followed** | A time window for every follower and following, or the exact time; likes come with the time of each like |
| 🔔 **New followers and unfollowers** | Schedule it daily: each run returns only who followed or left since the last check |
| 📈 **Follower count over time** | Every run adds a check to the profile's history: growth per day without any extra cost |
| 📧 **Leads from an audience** | Emails, websites and social links from bios, filters by followers, verification and bio keywords |
| ❤️ **Beyond followers** | Likers and reposters of a post, list and starter pack members, people search: one Actor, one table |
| 💰 **$0.44 per 1,000 accounts** | Counts, follow times, filters, tracking and the profiles table included |

#### Track new followers and unfollowers

1. Add the profiles to watch (yours or competitors'), choose **Followers** (or **Both**)
2. Turn on **Only new followers since the previous run** and/or **Unfollowers**, save as a task and add a schedule, e.g. daily
3. **First run** outputs the list as usual and remembers it. **Every later run** outputs only accounts that are new in the list (`change` = `new`) and, with Unfollowers, those that left it (`change` = `unfollowed`)

New followers are read newest first and the run stops at the previous check, so a daily run on a big account costs a few requests. Unfollowers need the whole list on every run and are checked for lists up to 50,000 accounts. What was seen is kept in your account (key-value store `bluesky-followers-state`) and shared by all your runs and tasks. Connect [Google Sheets](https://apify.com/s_actors/google-sheets-import-export), Slack or email with an integration to be notified.

#### Pricing

Pay per result, no subscription needed. Apify Scale and Business plans pay less:

| Event | Free and Starter plans | Scale plan | Business plan |
|---|---|---|---|
| Run start | $0.001 | $0.001 | $0.001 |
| Account in the results | $0.00044 | $0.00039 | $0.00034 |

| Task | Cost |
|---|---|
| 1,000 latest followers of an account, with counts | ~$0.44 |
| Whole following list of @pfrazee.com (645 accounts) | ~$0.29 |
| 10,000 people who liked a viral post | ~$4.40 |
| Daily new-follower tracker for a month | ~$0.03 + $0.00044 per new follower |

Profiles, posts and lists that are not found, accounts left out by filters and the profiles table are not charged.

#### Ready-made tasks

Open it, change the profile, and run:

| Task | What you get |
|---|---|
| [Export Bluesky Followers List](https://apify.com/s_actors/bluesky-followers-scraper/examples/export-bluesky-followers-list) | The followers of an account with their follower counts, bio and follow time |

#### FAQ

**Can it export all followers of a big account?** Yes, set **Max accounts per list** to `0`. Bluesky gives the whole list, 100 accounts per request, newest follow first (309,376 followers of @pfrazee.com = about 3,100 requests).

**How do you know when someone followed?** Bluesky stores each follow with a key made from the time it was created. The Actor reads it for every page of the list (`followedAfter` / `followedBefore`) or, with **Exact follow time**, for every account (`followedAt`). A few old or third-party apps used other keys: those rows have no follow time.

**Why are some followers missing?** Accounts with Bluesky's setting "discourage apps from showing my account to logged-out users" are left out, free; the run status shows how many. Deleted and deactivated accounts are not in the list either, so the row count can be lower than `sourceTotal`.

**Can I see who unfollowed me?** Yes: turn on **Unfollowers** and schedule the run. The first run remembers the list; each later run outputs the accounts that left it.

**Do I need a Bluesky account or an app password?** No. The Actor reads the public Bluesky API, the same data the bsky.app website shows.

**Where do the emails come from?** From what the account wrote in its bio. The Actor does not guess emails.

#### Use with the API and AI agents

Run it via the [Apify API](https://docs.apify.com/api/v2) from Python, Node.js or any HTTP client, or connect it to Claude, ChatGPT and other AI agents through the [Apify MCP server](https://mcp.apify.com): "Which of our Bluesky followers from this week have more than 10,000 followers, and what do their bios say?"

#### Other Bluesky tools

| Tool | What it does |
|---|---|
| [Threads Scraper](https://apify.com/s_actors/threads-scraper) | All posts, views and profiles of Threads accounts |
| [TikTok Followers Scraper](https://apify.com/s_actors/tiktok-followers-scraper) | Followers and following of TikTok accounts with their stats |
| [Google Sheets Import & Export](https://apify.com/s_actors/google-sheets-import-export) | Send the accounts to a Google Sheet |

#### Is it legal?

The Actor collects only public profiles and lists that Bluesky shows to any visitor, without logging in, and leaves out accounts that asked not to be shown to logged-out people. Handles, bios and emails are personal data: use them in line with GDPR, CAN-SPAM and other privacy laws, and do not send unsolicited messages.

# Actor input Schema

## `profiles` (type: `array`):

One per line: a handle (name.bsky.social or a custom domain like nytimes.com), @handle, a profile link (bsky.app/profile/...) or a DID. You get their followers, the accounts they follow, or both (see List).

## `lists` (type: `string`):

Which list of each profile to export. Both = followers and following, each row says which list it came from (inputType).

## `postUrls` (type: `array`):

Optional: post links (bsky.app/profile/<handle>/post/<id>). You get the accounts that liked the post (with the time of each like), reposted it, or both (see Post list).

## `postLists` (type: `string`):

For post links: the accounts that liked, reposted, or both.

## `listUrls` (type: `array`):

Optional: user lists (bsky.app/profile/<handle>/lists/<id>) or starter packs (bsky.app/starter-pack/<handle>/<id> or a go.bsky.app share link). You get every member account.

## `searchPeople` (type: `array`):

Optional: words to find accounts by name, handle or bio, as in the Bluesky search (e.g. journalist, photographer berlin). Up to 10 000 accounts per search, in Bluesky's order.

## `maxPerInput` (type: `integer`):

How many accounts to take from each list (followers of one profile, likes of one post, one starter pack...). 0 = all: the whole list, newest first.

## `includeProfileStats` (type: `boolean`):

Add followersCount, followsCount, postsCount, pinned post, banner and verification to every account. One extra light request per 25 accounts. Off = only what the list itself shows (name, handle, bio, avatar).

## `exactFollowTime` (type: `boolean`):

For followers and following: the exact time of every follow (followedAt). Slower, one request per account. Off = every row still gets the time window of its page (followedAfter / followedBefore, usually minutes or hours).

## `minFollowers` (type: `integer`):

Only accounts with at least this many followers (e.g. 1000 to find influencers among the followers).

## `maxFollowers` (type: `integer`):

Only accounts with at most this many followers. Leave empty for no limit.

## `verifiedOnly` (type: `boolean`):

Only accounts with the Bluesky blue check.

## `onlyWithEmail` (type: `boolean`):

Only accounts whose bio contains an email address (for outreach lists).

## `bioKeywords` (type: `array`):

Only accounts whose bio, name or handle contains one of these words (from the start of a word: design finds designer).

## `onlyNew` (type: `boolean`):

Output only accounts that were not in the same list in an earlier run of your account (key-value store bluesky-followers-state). The first run outputs the list as usual and remembers it. A run with no new accounts costs only the start.

## `detectUnfollows` (type: `boolean`):

Also output accounts that left the list since the previous run (change = unfollowed, unliked or removed). Reads the whole list on every run, for lists up to 50 000 accounts; the first run only remembers the list.

## `maxConcurrency` (type: `integer`):

How many profiles, posts and lists are read in parallel (100 accounts a request).

## `proxyConfiguration` (type: `object`):

Requests go direct to the Bluesky API and switch to Apify datacenter proxies only if it refuses them. The default works for most runs.

## `debugLog` (type: `boolean`):

Log every retried request (for troubleshooting).

## Actor input object example

```json
{
  "profiles": [
    "nytimes.com",
    "pfrazee.com"
  ],
  "lists": "followers",
  "postLists": "likes",
  "maxPerInput": 100,
  "includeProfileStats": true,
  "exactFollowTime": false,
  "verifiedOnly": false,
  "onlyWithEmail": false,
  "onlyNew": false,
  "detectUnfollows": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debugLog": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Every account: handle, name, followers, following, posts, verified, bio, joined, which list it came from.

## `profiles` (type: `string`):

One row per profile you entered: followers now and at the previous check, the change per day, new followers and unfollowers, bio contacts.

## `summary` (type: `string`):

The same profiles table as JSON, with the full follower count history.

## `all` (type: `string`):

Every field of every row.

# 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 = {
    "profiles": [
        "nytimes.com",
        "pfrazee.com"
    ],
    "maxPerInput": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/bluesky-followers-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 = {
    "profiles": [
        "nytimes.com",
        "pfrazee.com",
    ],
    "maxPerInput": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("s_actors/bluesky-followers-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 '{
  "profiles": [
    "nytimes.com",
    "pfrazee.com"
  ],
  "maxPerInput": 100
}' |
apify call s_actors/bluesky-followers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s_actors/bluesky-followers-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/DRhzHv6IMnU1bKin3/builds/ngoEL3JRnION0o6MW/openapi.json