Bluesky Followers Scraper

Export public Bluesky followers and following graph records from handles, profile URLs, or DIDs. Use it to map public audience relationships, build lead lists, monitor communities, and analyze account growth on Bluesky.

What does Bluesky Followers Scraper do?

Bluesky Followers Scraper collects public graph records from the Bluesky API.

It can export:

• Followers of a public Bluesky profile
• Accounts a public Bluesky profile follows
• Both followers and following records in one run
• Profile metadata for each related account
• Cursor metadata for auditability and resumable workflows

The actor does not require Bluesky login cookies.

Who is it for?

This actor is useful for:

• Social media analysts mapping public communities
• Creator and agency teams researching audience overlap
• Journalists studying public account networks
• Developer-relations teams finding relevant builders
• Growth teams building Bluesky prospect lists
• Researchers tracking public social graph changes
• Community managers exporting follower lists for enrichment

Input recipes

Export followers for one account

{
  "handles": ["bsky.app"],
  "mode": "followers",
  "maxItemsPerProfile": 20,
  "includeProfileDetails": true
}

Export following records

{
  "handles": ["apify.com"],
  "mode": "following",
  "maxItemsPerProfile": 50,
  "includeProfileDetails": true
}

Export both directions

{
  "handles": ["bsky.app", "apify.com"],
  "mode": "both",
  "maxItemsPerProfile": 100,
  "includeProfileDetails": true,
  "requestDelayMs": 150
}

Input fields

Field	Type	Description
handles	array	Bluesky handles, profile URLs, or DIDs.
mode	string	followers, following, or both.
maxItemsPerProfile	integer	Maximum graph records per input profile and selected mode.
includeProfileDetails	boolean	Include bio, avatar, counters, labels, and verification payloads.
sinceCursor	string	Optional Bluesky cursor to resume one handle and one direction.
requestDelayMs	integer	Delay between paginated graph requests.
maxRuntimeSeconds	integer	Optional 60–270 second work cap that saves a cursor checkpoint before cutoff.

Output fields

Each dataset item is one public graph relationship.

Field	Description
sourceHandle	Source account whose graph was exported.
sourceDid	Source account DID.
mode	Whether the row came from followers or following.
profileDid	Related profile DID.
profileHandle	Related profile handle.
displayName	Public display name when available.
description	Public profile bio when available.
avatarUrl	Public avatar URL when available.
followersCount	Related profile follower count.
followsCount	Related profile following count.
postsCount	Related profile post count.
createdAt	Related profile creation timestamp when returned by Bluesky.
indexedAt	Related profile index timestamp when returned by Bluesky.
verificationStatus	Verification payload returned by Bluesky.
labels	Public labels returned by Bluesky.
cursorPage	Cursor used to request the page that produced the row.
scrapedAt	Timestamp when the row was saved.

Example output

{
  "sourceHandle": "bsky.app",
  "sourceDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "mode": "followers",
  "profileDid": "did:plc:example",
  "profileHandle": "example.bsky.social",
  "displayName": "Example User",
  "description": "Public Bluesky profile bio",
  "followersCount": 1200,
  "followsCount": 300,
  "postsCount": 450,
  "scrapedAt": "2026-07-12T00:00:00.000Z"
}

API usage

You can run the actor from the Apify Console, Apify API, Apify CLI, or the official clients.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/bluesky-followers-scraper').call({
  handles: ['bsky.app'],
  mode: 'followers',
  maxItemsPerProfile: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/bluesky-followers-scraper').call(run_input={
    'handles': ['bsky.app'],
    'mode': 'followers',
    'maxItemsPerProfile': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~bluesky-followers-scraper/runs?token='$APIFY_TOKEN \
  -H 'Content-Type: application/json' \
  -d '{"handles":["bsky.app"],"mode":"followers","maxItemsPerProfile":20}'

MCP usage

You can use this actor through the Apify MCP server from compatible AI tools.

1. Configure the Apify MCP server with your Apify API token.
2. Ask your AI tool to run fetch_cat/bluesky-followers-scraper.
3. Provide the same JSON input you would use in the Apify Console.
4. Use the returned dataset items in your analysis or workflow.

Claude Desktop / Claude Code example:

$claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/bluesky-followers-scraper

Generic MCP JSON configuration:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "fetch_cat/bluesky-followers-scraper"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}

Example prompt:

Run Bluesky Followers Scraper for bsky.app, collect 20 followers, and summarize common profile themes.

Pricing

This actor uses pay-per-event pricing on Apify. A start event is charged once per valid run, and the primary event is charged for each saved follower/following graph record.

Event	What is charged	Price
Start	One valid Actor run	$0.005
Graph record extracted	Each saved public follower/following row	Free $0.00002762875; Bronze $0.000024025; Silver $0.0000187395; Gold $0.000014415; Platinum $0.00000961; Diamond $0.000006727

At the Free tier, 1,000 saved graph records cost about $0.03, plus the run start event. Failed lookups and malformed records are not saved as graph records.

To control costs:

• Start with maxItemsPerProfile set to 20.
• Use followers or following instead of both unless you need both directions.
• Test one handle before adding larger batches.
• Increase limits only after confirming the output shape suits your workflow.

Data source

The actor uses public Bluesky endpoints for public profiles and public graph pages. It only collects data returned by Bluesky for public accounts.

Legality and responsible use

You are responsible for using the exported data lawfully and in line with your use case. Avoid collecting unnecessary personal data, respect applicable privacy rules, and follow Bluesky and Apify terms. Do not use the actor for harassment, spam, or abusive targeting.

Performance tips

• Keep the default requestDelayMs for larger runs.
• Split very large account lists into smaller runs.
• Use includeProfileDetails: false when you only need handles and DIDs.
• Use profile URLs only when convenient; handles and DIDs are simpler.
• A run accepts up to 100 unique source profiles and up to 5,000 records per source and selected direction.
• Large lists stop before the run timeout so saved rows and a checkpoint can be persisted.

Reliable pagination and checkpoints

The Actor follows Bluesky cursors, deduplicates profile DIDs within each source and direction, and stops on a repeated cursor instead of looping. It checks successful API responses for the expected graph shape and retries temporary API/network failures with bounded backoff.

When a large run reaches its safe deadline, already saved rows remain available. Set maxRuntimeSeconds (60–270) when you want a predictable work cap; the Actor always uses the earlier of that cap and the platform timeout. RUN_SUMMARY records the result, warnings, and any source-level failures. If a graph page remains, PENDING_WORK records its source handle, DID, direction, cursor, and remaining limit. To resume, start a new run with that one source handle, the recorded direction, and the cursor in sinceCursor.

Troubleshooting

If a handle returns no records, verify that the account exists and is public. A valid public account can legitimately have an empty follower/following list. If every requested source is unavailable or rejected, the run fails and RUN_SUMMARY lists the source-level errors. If a run stops early, inspect PENDING_WORK, then resume the affected source and direction with its cursor. If Bluesky temporarily rate-limits requests, retry later with a delay.

FAQ

Do I need a Bluesky account?

No. The actor collects public graph records and does not require login.

Can I scrape private accounts?

No. The actor only exports public data returned by Bluesky.

Can I resume a run?

Advanced users can pass a sinceCursor value from PENDING_WORK to resume one source and one direction. Most users should leave it empty. For both, resume followers and following in separate runs so the cursor cannot be applied to the wrong graph.

Does it use a browser?

No. It is an HTTP/API actor designed for low memory usage and fast runs.

Can I export both followers and following?

Yes. Set mode to both. Each selected direction can save up to maxItemsPerProfile records per source profile.

What happens when one source profile fails in a batch?

The Actor preserves successful public graph rows from other source profiles and records the failed source in RUN_SUMMARY. A batch fails rather than reporting a misleading empty success when every requested source fails.