# Bluesky Profile Scraper (`scraperoka/bluesky-profile-scraper`) Actor

🚀 Bluesky Profile Scraper extracts bio, posts, followers & engagement insights from Bluesky profiles. 📊 Perfect for lead gen, research, and competitive analysis—turn public data into actionable intel fast. ✅ No coding required.

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

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Profile Details Scraper 🔍

**Bluesky Profile Details Scraper** is an Apify actor that extracts comprehensive profile metadata from Bluesky (bsky.app) profiles—so you can scrape Bluesky user profile data at scale without manual copy-pasting. It’s a **Bluesky profile scraper** and **Bluesky profile details scraper** built for anyone who needs reliable **Bluesky account details extraction**, including follower and post counts plus key profile fields. Whether you're a marketer, researcher, or data analyst, this automated Bluesky profile scraping tool helps you turn public web data into structured results—saving you hours of manual work.

### Why choose Bluesky Profile Details Scraper?

| Feature | Benefit |
|---|---|
| ✅ All-in-one Bluesky profile data extraction | Get follower counts, post counts, and user details in a single run |
| ✅ Reliability with built-in proxy support | Better chances of successful scraping across different runs |
| ✅ Structured JSON output | Clean, schema-ready results you can analyze immediately |
| ✅ Error-aware results per URL | You receive an `error` flag and `message` when a profile fails |
| ✅ Designed for bulk processing | Process multiple Bluesky profile URLs in one actor run |
| ✅ Easy dataset export workflow | Output is pushed to Apify dataset for JSON/CSV export |

### Key features

- 🔎 **Bluesky profile information extractor**: Extracts profile metadata for each provided Bluesky profile URL.
- 📊 **Follower and posts metrics included**: Captures `followers_count`, `follows_count`, and `posts_count` as part of the profile fields.
- 🧾 **Bio and metadata fields**: Returns mapped profile keys such as display name, creation timestamps, and more profile-related attributes.
- 🛡️ **Resilient scraping workflow**: Includes built-in proxy support for reliable scraping and continues processing the rest of your list.
- 💾 **Structured results saved automatically**: Pushes an array of per-profile results to the Apify dataset using `Actor.push_data`.
- 🌐 **Flexible URL input**: Accepts a list of Bluesky profile URLs (for example: `https://bsky.app/profile/handle.bsky.social`).
- ⏱️ **Polite pacing between requests**: Adds delays between profile requests to improve stability during bulk runs.

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "urls": [
    "https://bsky.app/profile/theliamnissan.bsky.social"
  ]
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `urls` | No | A list of Bluesky profile URLs to scrape (e.g., `https://bsky.app/profile/handle.bsky.social`). |

> Notes:
> The actor reads `urls` from input. If you don’t provide any URLs, it logs a warning and stops.

### Output

The actor saves each profile’s data in JSON format.

Example output (array of results):

```json
[
  {
    "url": "https://bsky.app/profile/theliamnissan.bsky.social",
    "error": false,
    "display_name": "Example display name",
    "created_at": "2020-01-01T00:00:00.000Z",
    "followers_count": 123,
    "follows_count": 45,
    "posts_count": 67,
    "viewer": {},
    "labels": [],
    "error": false
  },
  {
    "url": "https://bsky.app/profile/invalid-handle.bsky.social",
    "error": true,
    "message": "An error message describing what went wrong"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `url` | string | The Bluesky profile URL that was processed. |
| `error` | boolean | Indicates whether the scrape failed (`true`) or succeeded (`false`). |
| `message` | string | Present when `error` is `true`; contains the error details. |
| `display_name` | string | The profile display name (mapped from `displayName`). |
| `created_at` | string | Profile creation timestamp (mapped from `createdAt`). |
| `indexed_at` | string | Profile indexed timestamp (mapped from `indexedAt`). |
| `followers_count` | number | Number of followers (mapped from `followersCount`). |
| `follows_count` | number | Number of accounts the user follows (mapped from `followsCount`). |
| `posts_count` | number | Number of posts (mapped from `postsCount`). |
| `pinned_post` | object | Pinned post information (mapped from `pinnedPost`). |
| `starter_packs` | array | Starter packs associated with the profile (mapped from `starterPacks`). |
| `activity_subscription` | object | Activity subscription info (mapped from `activitySubscription`). |
| `allow_subscriptions` | boolean | Whether subscriptions are allowed (mapped from `allowSubscriptions`). |
| `associated` | object | Associated entities (mapped from `associated`). |
| `viewer` | object | Viewer-specific info (mapped from `viewer`). |
| `labels` | array | Labels applied to the profile (mapped from `labels`). |

You can export the dataset from Apify to formats like JSON or CSV depending on your workflow needs.

### How to use Bluesky Profile Details Scraper (via Apify Console)

1. **Open Apify Console**
   Go to [console.apify.com](https://console.apify.com) and log in.

2. **Find the actor**
   Search for **Bluesky Profile Details Scraper** in the Actors catalog and open its page.

3. **Go to the INPUT section**
   Use the built-in input editor and paste your `input.json`-style content.

4. **Add your profile URLs**
   In `urls`, paste one or more Bluesky profile URLs like `https://bsky.app/profile/handle.bsky.social`.

5. **Run the actor**
   Click **Run**. The actor will start processing each URL, with short pauses between profiles to keep the run stable.

6. **Monitor progress in logs**
   Watch the execution logs for progress messages as each profile URL is processed.

7. **Review results in the dataset**
   After completion, open the **OUTPUT** dataset. Each URL will produce a result object with `error: true/false`.

8. **Export your data**
   Export to JSON/CSV from the dataset view for further analysis or CRM/data processing pipelines.

No coding required — get accurate results in minutes with this **Bluesky Profile Details Scraper**. ✅

### Advanced features & SEO optimization

- 🛠️ **Engineered for Bluesky profile data scraping**: Designed to excel at scraping Bluesky user profile data and turning it into analysis-ready records.
- 🔄 **Per-URL error handling for bulk workflows**: Even if one profile fails, the actor returns a structured error object for that specific URL.
- 🌐 **Bluesky API profile scraper approach**: Retrieves profile metadata through publicly accessible profile data endpoints and maps keys into a consistent snake\_case structure.
- 📊 **Bluesky follower and following scraper value**: Includes follower and following metrics (`followers_count`, `follows_count`) plus post counts for deeper profile analytics.
- 💾 **Structured output for downstream processing**: Results are pushed to the dataset as a JSON array, making it easier to integrate into research or data pipelines.

### Best use cases

- 📈 **Lead generation teams**: Build targeted contact and outreach lists by pairing profile metadata with your existing enrichment workflow.
- 🔬 **Market researchers**: Compare follower and post metrics across profiles to quantify audience reach and engagement signals.
- 🧠 **Social media analysts**: Track creator growth by repeatedly scraping profile details at intervals and analyzing trends.
- 🧾 **Brand partnership managers**: Create shortlists of relevant accounts using structured profile metadata and counts.
- 👥 **Community managers**: Identify active users and recurring contributors by reviewing posts and profile metadata at scale.
- 💻 **Developer pipelines & automation**: Feed Bluesky profile information extractor results into your own ETL jobs using dataset exports.
- 📊 **Data scientists**: Assemble clean inputs for modeling by extracting consistent fields like display name, follower counts, and timestamps.

### Technical specifications

- **Supported Input Formats**
  - ✅ `urls`: an array of Bluesky profile URLs (strings), such as `https://bsky.app/profile/handle.bsky.social`
- **Proxy Support**
  - ✅ Includes built-in proxy support for reliable scraping
- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience (details handled internally)
- **Dataset Structure**
  - ✅ JSON array of profile result objects pushed via `Actor.push_data` (with per-URL `error` and `message` on failures)
- **Rate Limits & Performance**
  - ⚠️ Processing time depends on profile accessibility and network conditions; the actor includes polite delays between requests
- **Limitations**
  - ❌ Profiles that are not accessible or fail to load may return `error: true` with a `message`
  - ❌ Private or restricted information is not guaranteed since the actor works with publicly available data

### FAQ

#### Can I scrape multiple Bluesky profiles in one run?

✅ Yes. Provide multiple Bluesky profile URLs in the `urls` array, and the actor will process them one by one, pushing all results into the dataset.

#### What output do I get back after the run?

✅ The actor saves results in JSON format as an array of objects. Each object includes the original `url`, an `error` flag, and either extracted profile fields or an error `message` when scraping fails.

#### Does this actor return follower and post counts?

✅ Yes. The output includes `followers_count`, `follows_count`, and `posts_count` (mapped from the profile metadata).

#### Do I need to provide proxy settings?

✅ No. The actor includes built-in proxy support for reliability. Your input schema only requires `urls`.

#### Is login or authentication required?

❌ No. The actor is designed to extract profile metadata from publicly accessible sources, so you can run it with only the profile URLs.

#### Can I use the output for analysis or CRM enrichment?

✅ Yes. The structured JSON dataset makes it easy to export to downstream tools for analytics, segmentation, or enrichment pipelines.

#### How do I contact support or request changes?

💡 For feedback and feature requests related to this **Bluesky Profile Details Scraper**, email <dataforleads@gmail.com>.

#### How can I request data removal?

For data removal requests, email <dataforleads@gmail.com>.

### Support & feature requests

Want to improve this **Bluesky Profile Details Scraper**? 💬\
Share your feedback and ideas—especially if you want additional fields, export enhancements, or better bulk workflow support.

- 💡 **Feature Requests**: Examples include adding more output fields, improving dataset usability for exports, or supporting additional input conveniences for scraping Bluesky profile details.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this Bluesky profile scraper. 🚀

*If you’re looking for a reliable automated way to scrape Bluesky user profile data, this is the most comprehensive and SEO-optimized **Bluesky Profile Details Scraper** for the job.*

### Disclaimer

**This tool accesses publicly accessible sources** to extract profile metadata. It does not access private profiles or authenticated data, and it does not bypass access controls on the platform.

You are responsible for ensuring your use complies with applicable laws and regulations (including GDPR/CCPA), spam regulations, and the platform’s Terms of Service.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and only for legitimate purposes.

# Actor input Schema

## `urls` (type: `array`):

List of Bluesky profile URLs to scrape (e.g., https://bsky.app/profile/handle.bsky.social).

## Actor input object example

```json
{
  "urls": [
    "https://bsky.app/profile/theliamnissan.bsky.social"
  ]
}
```

# 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 = {
    "urls": [
        "https://bsky.app/profile/theliamnissan.bsky.social"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/bluesky-profile-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 = { "urls": ["https://bsky.app/profile/theliamnissan.bsky.social"] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/bluesky-profile-scraper").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 '{
  "urls": [
    "https://bsky.app/profile/theliamnissan.bsky.social"
  ]
}' |
apify call scraperoka/bluesky-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Profile Scraper",
        "description": "🚀 Bluesky Profile Scraper extracts bio, posts, followers & engagement insights from Bluesky profiles. 📊 Perfect for lead gen, research, and competitive analysis—turn public data into actionable intel fast. ✅ No coding required.",
        "version": "0.1",
        "x-build-id": "QQfDwjGLRPZEbhzlR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~bluesky-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-bluesky-profile-scraper",
                "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/scraperoka~bluesky-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-bluesky-profile-scraper",
                "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/scraperoka~bluesky-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-bluesky-profile-scraper",
                "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",
                "properties": {
                    "urls": {
                        "title": "Bluesky Profile URLs",
                        "type": "array",
                        "description": "List of Bluesky profile URLs to scrape (e.g., https://bsky.app/profile/handle.bsky.social).",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```