# Bluesky Creator & Audience Intelligence — Followers, Bio Links (`foxlabs/bluesky-creator-intelligence`) Actor

Find and enrich Bluesky creators at scale from the official AT Protocol API: search by keyword, look up handles, or export an account's followers/following. Each profile returns follower/post counts, account age, bio, contact links and optional engagement rate. No API key.

- **URL**: https://apify.com/foxlabs/bluesky-creator-intelligence.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (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

$3.00 / 1,000 creator delivereds

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 Scraper — Creator, Follower & Engagement Data 🚀

**foXLabs creator & company data:** [Y Combinator](https://apify.com/foxlabs/ycombinator-company-data) · [Product Hunt](https://apify.com/foxlabs/producthunt-launch-leads) · [Crunchbase](https://apify.com/foxlabs/crunchbase-company-intelligence) · [Company Enrichment](https://apify.com/foxlabs/company-enrichment)

🎉 Turn Bluesky into clean, structured creator data — no login, no API key, one row per creator, ranked by real reach and engagement.
Built for influencer marketing, creator lead-gen and social research.

### 🔍 What is the Bluesky Scraper — and when should you use it?

Bluesky is a fast-growing open social network. Give this actor keywords, specific handles, or one account whose audience you want, and it returns matching creators — follower/post counts, account age, a verified **domain**, bio and an **engagement rate** from recent posts — as clean rows you can filter, export, or feed to a spreadsheet, a CRM or an AI agent.

**Use it when you need:** to discover creators in a niche ranked by reach and engagement; to enrich a list of handles; to export a competitor's or a brand's followers/following; or to build an influencer shortlist with a verified domain to reach them.

**Use something else when:** you need post/mention monitoring — Bluesky's public API does not allow unauthenticated post search, so this Actor focuses on **creators and audiences**, not posts.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/bluesky-creator-intelligence`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered creator, never for errors.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want to find and enrich Bluesky creators using the Apify Actor
`foxlabs/bluesky-creator-intelligence`.

Input: `keywords` finds creators by niche; `handles` looks up specific accounts; `audienceOf`
exports one account's followers/following. `minFollowers` filters; `includeEngagement` adds an
engagement rate. Each row has handle, displayName, followersCount, postsCount, domain and bio.

Start with:
{ "keywords": ["photography"], "minFollowers": 1000, "includeEngagement": true, "maxResults": 50 }

Ask me the niche or accounts I want, run the Actor, then summarise the creators as a table.
```

Things you can ask your agent for:

- "Find photography creators on Bluesky with over 10k followers, ranked by engagement rate."
- "Enrich these 20 handles with their follower counts and domains."
- "Export the followers of this brand account."

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/bluesky-creator-intelligence.md`.

### 📋 Overview

Everything you need to turn Bluesky into a clean, structured creator database — reach, engagement and a verified domain — in one actor, with no login, cookies or API key.

**Why teams pick this actor:**

- ✅ **Three ways in** — keyword discovery, handle lookup, and audience (followers/following) export.
- ⚡ **Engagement rate, not just follower count** — optionally averages recent posts into likes/reposts/replies and an engagement rate.
- 🎯 **A verified domain** — a custom-domain handle is a domain the creator has verifiably proven they control, surfaced as `website`/`domain`.
- 🔴 **Live, official source** — Bluesky's public AT Protocol AppView; no key, no login, no browser.
- 💰 **Pay only for results** — per-creator pricing, empty lookups never billed.
- 🤖 **Agent-ready** — MCP + x402 agentic payments.

### ✨ Features

- 🔍 **Keyword search, handle lookup, audience export** — one actor, three modes.
- 📊 **Reach metrics** — follower, following and post counts, plus account age.
- ❤️ **Engagement rate (optional)** — average likes, reposts and replies over recent original posts, divided by followers.
- 🌐 **Verified domain + bio links** — `website`/`domain` from the handle, plus any links/emails in the bio.
- 📦 **Clean export** — deduplicated camelCase rows, ready for CSV/Excel/JSON.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~bluesky-creator-intelligence/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["photography"], "minFollowers": 1000, "includeEngagement": true, "maxResults": 50}'
```

### 🚀 Getting Started (3 steps)

1. **Pick your input** — `keywords` for discovery, `handles` for lookup, or `audienceOf` for an audience export.
2. **Tune it** — set `minFollowers` and turn on `includeEngagement` for the engagement rate.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

```json
{
  "keywords": ["photography"],
  "minFollowers": 1000,
  "includeEngagement": true,
  "engagementSampleSize": 20,
  "maxResults": 50
}
```

| Field | Type | Description |
|---|---|---|
| `keywords` | array | Niches/keywords to discover creators. |
| `handles` | array | Specific handles or DIDs to look up (takes priority over keywords). |
| `audienceOf` | string | Export this account's followers/following (takes priority). |
| `audienceType` | string | `followers` (default) or `follows`. |
| `minFollowers` | integer | Keep only creators with at least this many followers. |
| `includeEngagement` | boolean | Analyse recent posts to compute an engagement rate. |
| `engagementSampleSize` | integer | Recent posts to average (1–100, default 20). |
| `maxResults` | integer | Max creators to deliver (0 = 1000). |

### 📤 Output

One row per creator, saved to the dataset.

| Field | Type | Description |
|---|---|---|
| `handle` / `displayName` / `did` | string | Identity |
| `followersCount` / `followsCount` / `postsCount` | integer | Reach metrics |
| `accountCreatedAt` | string | Account age |
| `website` / `domain` | string | From a verified custom-domain handle, else the first bio link |
| `bio` | string | Profile description |
| `links` / `emails` | array | Extracted from the bio, where present |
| `avgLikes` / `avgReposts` / `avgReplies` | integer | Engagement averages (when enabled) |
| `engagementRatePct` | number | Engagement ÷ followers, as a percentage |
| `verifiedStatus` | string | Bluesky verification status, where present |
| `profileUrl` | string | Link to the profile |

```json
{
  "handle": "jocelynanderson.bsky.social",
  "displayName": "Jocelyn Anderson Photography",
  "followersCount": 127178,
  "postsCount": 2391,
  "accountCreatedAt": "2023-11-01T00:00:00.000Z",
  "domain": "jocelynanderson.com",
  "avgLikes": 589,
  "engagementRatePct": 0.521,
  "profileUrl": "https://bsky.app/profile/jocelynanderson.bsky.social",
  "source": "Bluesky (AT Protocol)"
}
```

### 💼 Use cases

**1. Influencer discovery** — find creators in a niche ranked by engagement, not just follower count.
*Input:* `keywords` + `minFollowers` + `includeEngagement`. *Output:* creators with engagement rate. *Use:* shortlist the ones who actually move their audience.

**2. Creator lead-gen** — build an outreach list with a verified domain per creator.
*Input:* `keywords` or `handles`. *Output:* creators + `domain`. *Use:* enrich the domain to an email and reach out.

**3. Audience research** — study a competitor's or a brand's following.
*Input:* `audienceOf` = the account, `audienceType` = followers. *Output:* the enriched audience. *Use:* understand who follows them.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/bluesky-creator-intelligence').call({
  keywords: ['photography'], minFollowers: 1000, includeEngagement: true, maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/bluesky-creator-intelligence').call(
    run_input={'keywords': ['photography'], 'minFollowers': 1000, 'includeEngagement': True, 'maxResults': 50}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the actor API with your input → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay-per-event: **$0.003 per delivered creator**. Empty lookups are never billed; turning on engagement adds one request per creator but the price is unchanged. [View current pricing.](https://apify.com/foxlabs/bluesky-creator-intelligence)

### ❓ FAQ

**Do I need a Bluesky API key or login?** No. This reads Bluesky's public AT Protocol AppView — the same endpoint the Bluesky website uses.

**How do I scrape an account's followers?** Set `audienceOf` to the handle and `audienceType` to `followers` (or `follows`); the actor pages through the whole list and enriches each one.

**Can I get a creator's engagement rate?** Yes — turn on `includeEngagement` for average likes/reposts/replies and an engagement rate (engagement ÷ followers).

**Does it search Bluesky posts or mentions?** No. Bluesky's public API does not allow unauthenticated post search, so this Actor focuses on creators and audiences.

**Why are `website`/`links`/`emails` sometimes empty?** `website`/`domain` come from a verified custom-domain handle or a bio link; `links`/`emails` are extracted from the bio. Not every creator has them, so they are returned only when present — never fabricated.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **Fewer creators than expected** — `minFollowers` may be filtering them out, or the keyword is narrow; lower the threshold or broaden the keyword.
- **No engagement fields** — turn on `includeEngagement`; a creator with no recent original posts returns none.
- **`website`/`domain` empty** — the creator uses a default `*.bsky.social` handle and lists no bio link; nothing is fabricated.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to Bluesky Social, PBC. "Bluesky" and related marks belong to their owners and are used here for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads only public profile data from Bluesky's official public API. Profile data (handles, display names, bios) can be personal data, which is protected by the GDPR and similar laws, so only process it with a legitimate basis. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab
- 🧰 **More clean B2B data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.2 — 2026-10-12

- Add `website` and `domain` from a verified custom-domain handle (or the first bio link) — the join key for CRM and enrichment.

#### 0.1.1 — 2026-10-12

- Add pay-per-event billing: one `creator` event per delivered creator.

#### 0.1.0 — 2026-10-11

- Initial release: keyword search, handle lookup and audience export, with reach metrics, bio contact extraction and optional engagement rate.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/bluesky-creator-intelligence/changelog.md

# Actor input Schema

## `keywords` (type: `array`):

Find creators whose name or bio matches these keywords (e.g. "photography", "crypto", "indie game"). Used when no handles or audience account is given.

## `handles` (type: `array`):

Look up specific accounts by handle or DID (e.g. "bsky.app", "pfrazee.com"). The leading @ is optional. Takes priority over keyword search.

## `audienceOf` (type: `string`):

Export the followers or following of this one account (handle or DID). Takes priority over keywords. Large accounts can have millions of followers — use Max results.

## `audienceType` (type: `string`):

When exporting an audience, whether to pull the account's followers or the accounts it follows.

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

Only keep creators with at least this many followers (useful to skip inactive / tiny accounts).

## `includeEngagement` (type: `boolean`):

Analyse each creator's recent posts to compute average likes/reposts/replies and an engagement rate. Adds one request per creator.

## `engagementSampleSize` (type: `integer`):

How many recent original posts to average when computing engagement (1-100).

## `maxResults` (type: `integer`):

Maximum creators to deliver (0 = default 1000).

## Actor input object example

```json
{
  "keywords": [
    "photography"
  ],
  "handles": [],
  "audienceType": "followers",
  "includeEngagement": false,
  "engagementSampleSize": 20,
  "maxResults": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `report` (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 = {
    "keywords": [
        "photography"
    ],
    "handles": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/bluesky-creator-intelligence").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 = {
    "keywords": ["photography"],
    "handles": [],
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/bluesky-creator-intelligence").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 '{
  "keywords": [
    "photography"
  ],
  "handles": []
}' |
apify call foxlabs/bluesky-creator-intelligence --silent --output-dataset

```

## MCP server setup

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

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/7Tgnfql76vPmvIm3J/builds/owR4HD0opedYZSjSc/openapi.json