# Bluesky Followers Scraper - Export Audiences (`dataio/bluesky-followers-exporter`) Actor

Export Bluesky followers, following lists, keyword search results and post likers, enriched with follower counts, bios and profile URLs. Build audience lists and influencer shortlists from Bluesky. No login, no cookies, no proxies needed.

- **URL**: https://apify.com/dataio/bluesky-followers-exporter.md
- **Developed by:** [Tom Awake](https://apify.com/dataio) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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

### What does Bluesky Followers Scraper do?

Export any Bluesky audience to **CSV, JSON, Excel or an API feed** — followers,
following, keyword matches, or everyone who liked a post — enriched with
follower counts, bios, post counts and profile URLs.

**No login. No cookies. No proxies. Nothing to break.**

### Why this one doesn't break

Most social scrapers fight an anti-bot system. They need logged-in accounts,
proxy rotation and constant patching, and they fail the week the target
changes a defence.

This Actor reads Bluesky's **official public AT Protocol API**
(`public.api.bsky.app`) — the endpoint Bluesky publishes and recommends for
public-web use. There is no authentication to expire, no account to get
suspended, and no anti-bot arms race. Public data, sanctioned access, stable
output.

### What you get

| Field | Description |
|---|---|
| `handle` | `alice.bsky.social` |
| `displayName` | Profile display name |
| `did` | Permanent decentralised identifier — stable across handle changes |
| `description` | Full bio, newlines flattened |
| `followersCount` | Followers |
| `followsCount` | Accounts they follow |
| `postsCount` | Total posts |
| `createdAt` | Account creation date |
| `indexedAt` | Last index date |
| `avatar` | Avatar image URL |
| `profileUrl` | `https://bsky.app/profile/<handle>` |

### Four modes

**Followers** — everyone who follows an account. Give it a handle.

**Following** — everyone an account follows. Give it a handle.

**Keyword search** — accounts whose name or bio matches a term. Give it
something like `climate tech` or `game developer`.

**Post likers** — everyone who liked a specific post. Paste the post URL
straight from your browser; the `at://` URI form works too.

### Use cases

- **Audience research** — export a competitor's followers and sort by
  follower count to find the accounts that matter.
- **Lead generation** — search bios by keyword, filter by follower count,
  hand the list to your outreach tool.
- **Community mapping** — export the following list of a hub account to map
  who a niche actually pays attention to.
- **Influencer discovery** — rank accounts in a niche by real follower and
  post counts, not vanity metrics.
- **Engagement analysis** — export the likers of a high-performing post to
  see exactly who responded.

### Input

```json
{
  "mode": "followers",
  "target": "bsky.app",
  "maxItems": 200,
  "enrich": true
}
```

Run it with no configuration at all and it exports 200 enriched followers of
`bsky.app`, so you can see the output shape before deciding anything.

| Field | Default | Notes |
|---|---|---|
| `mode` | `followers` | `followers`, `following`, `search`, `likers` |
| `target` | `bsky.app` | Handle, search term, or post URL — a leading `@` is fine |
| `maxItems` | `200` | Up to 50,000; pagination is automatic |
| `enrich` | `true` | Adds counts and bios in batches of 25; turn off for the fastest handle-only list |

### Output

One row per account, deduplicated by `did`. Feed it straight into a
spreadsheet, or pull it from the Apify dataset API in JSON, CSV, XLSX or XML.

```json
{
  "handle": "alice.bsky.social",
  "displayName": "Alice",
  "did": "did:plc:xxxxxxxxxxxxxxxxxxxxxxxx",
  "description": "Building things on the AT Protocol",
  "followersCount": 4821,
  "followsCount": 613,
  "postsCount": 2044,
  "createdAt": "2023-05-02T09:14:22.000Z",
  "profileUrl": "https://bsky.app/profile/alice.bsky.social"
}
```

### Notes on limits and behaviour

- Rate limits are respected. On HTTP 429 the Actor reads the
  `ratelimit-reset` header and waits exactly as long as it is told, backing
  off exponentially if the header is absent.
- Transient 5xx responses are retried; a bad handle fails fast with the
  API's own message instead of a generic error.
- An account deleted between collection and enrichment keeps its basic
  fields rather than vanishing from the export.
- Very large audiences take time — an account with a million followers is a
  million paginated records. Use `maxItems` deliberately.

### Data and privacy

This Actor reads only data Bluesky publishes publicly through its own API.
It does not access private accounts, direct messages, email addresses or
anything behind a login, because those endpoints are not reachable without
authentication and the Actor holds no credentials.

Exported profiles may still constitute personal data. If you are in the EU or
UK and you use this output for outreach, you are the data controller for what
you do with it: have a lawful basis, tell people where their data came from
on first contact, and honour objections. That obligation is yours, not the
tool's.

### How much does it cost?

You pay per account returned: **$0.003 each**, that is $3.00 per 1,000. There is no start fee, and subscription plans pay less per account.

The example input below asks for up to 200 accounts, so it costs **$0.60 at most**.

If a run reaches the spending limit you set, the output stops at that limit and never goes past it. You are never charged for rows that were not delivered.

### Use Bluesky Followers Scraper as an API

Call it from your own code with the Apify client, here in Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("DataIO/bluesky-followers-exporter").call(run_input={
    'mode': 'followers',
    'target': 'bsky.app',
    'maxItems': 200,
    'enrich': True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

It also works from JavaScript, Make, Zapier, n8n, and from AI agents through the Apify MCP server.

### Other actors you might like

- [Wikipedia Pageviews Scraper](https://apify.com/DataIO/wikipedia-pageviews-by-language): By Language
- [OpenAlex Scraper](https://apify.com/DataIO/openalex-authors-affiliations): Research Authors & Funders
- [Google Trends Scraper & API](https://apify.com/DataIO/google-trends-scraper): 100 Keywords

### FAQ

#### Is it legal to use this data?

The actor reads public data from its official source, without logging in and without bypassing any access control. What you do with the data, for example contacting people listed in it, is your responsibility under the laws that apply to you, such as GDPR in Europe.

#### Can I run it on a schedule?

Yes. Create a schedule in Apify Console, daily or weekly for example, and each run delivers a fresh dataset, which you can send by email, webhook or integration.

#### Can AI agents use it?

Yes. It is available through the Apify MCP server, and every input field is described in its input schema, so an agent can call it directly.

# Actor input Schema

## `mode` (type: `string`):

Followers and Following take a handle. Keyword search takes a search term. Post likers takes a post URL.

## `target` (type: `string`):

A handle such as bsky.app (Followers / Following), a search term such as climate tech (Keyword search), or a post URL such as https://bsky.app/profile/alice.bsky.social/post/3l6ove... (Post likers). The leading @ is optional.

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

Stops once this many accounts have been collected. Large audiences are paginated automatically.

## `enrich` (type: `boolean`):

Follower, following and post counts plus the full bio are fetched in batches of 25. Turn this off for the fastest possible handle-only list.

## Actor input object example

```json
{
  "mode": "followers",
  "target": "bsky.app",
  "maxItems": 200,
  "enrich": true
}
```

# Actor output Schema

## `results` (type: `string`):

Every row produced by the run, in JSON.

# 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 = {
    "target": "bsky.app",
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataio/bluesky-followers-exporter").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 = {
    "target": "bsky.app",
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("dataio/bluesky-followers-exporter").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 '{
  "target": "bsky.app",
  "maxItems": 200
}' |
apify call dataio/bluesky-followers-exporter --silent --output-dataset

```

## MCP server setup

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

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/uvqhr6lSYQhPXgQhQ/builds/DbUyRpJ9chGgauZ0B/openapi.json