# Bluesky Starter Pack Discovery Scraper (`automation-lab/bluesky-starter-pack-creator-discovery-scraper`) Actor

Discover public Bluesky Starter Packs and optionally expand their curated member profiles for focused creator research.

- **URL**: https://apify.com/automation-lab/bluesky-starter-pack-creator-discovery-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Starter Pack Discovery Scraper

Discover public Bluesky Starter Packs, the people who curate them, and—when you choose—profiles in their curated lists. Use it to turn topic searches into structured community and creator research.

### What does it do?

This actor searches Bluesky's public Starter Pack index for your topics. Each dataset row represents one Starter Pack, with its title, description, AT URI, curator, referenced list, feeds, and join counts.

Enable member expansion to include public profiles from the referenced curated list in the same row. No Bluesky login, cookie, or private endpoint is required.

### Who is it for?

- **Influencer agencies** building topical creator seed lists.
- **Social-listening teams** mapping public communities around a niche.
- **Newsletter editors** finding subject-matter voices and curated sources.
- **Community researchers** studying how public Bluesky groups are organized.
- **Developers** who need a repeatable public-data input for a pipeline.

### Why use Starter Packs?

A profile search starts from individual accounts. A Starter Pack starts from a public curation decision: someone has grouped relevant accounts, a list, and sometimes feeds around a topic. That makes it useful for discovering community entry points instead of only the most individually visible profiles.

### Data you get

| Field | Meaning |
| --- | --- |
| `packName` | Public Starter Pack name |
| `packDescription` | Curator-provided context |
| `creator` | Curator DID, handle, profile URL, and public profile details |
| `packUri` / `listUri` | Stable AT Protocol identifiers |
| `feeds` | Referenced public feeds |
| `joinedAllTimeCount` | Public all-time Starter Pack join counter |
| `members` | Optional nested public curated-list profiles |
| `sourceUrl` | Public Bluesky API source endpoint |

### Quick start

1. Enter one or more topical phrases in **Starter Pack search queries**.
2. Keep **Maximum Starter Packs** low for your first run.
3. Turn on **Expand curated list members** when you need profile-level seeds.
4. Export the default dataset as JSON, CSV, or connect it to your workflow.

### Search query ideas

Try topics a community curator would use, not only broad industry labels.

- `technology`
- `climate`
- `indie games`
- `science`
- `journalism`
- `open source`

Run multiple related queries when you need broader coverage. Dataset rows retain the originating `query` so you can compare intent later.

### Input reference

#### Starter Pack search queries

`queries` is required. Provide a list of topics, communities, or creator niches. Empty entries are ignored and repeated values are deduplicated.

#### Maximum Starter Packs

`maxItems` is the total number of Starter Pack rows across every query, not per query. The default is 10; the maximum is 1,000.

#### Expand curated list members

`expandMembers` requests the public list referenced by each discovered pack. If a list cannot be read, the actor still saves the Starter Pack metadata and logs the expansion problem.

#### Maximum members per Starter Pack

`maxMembersPerPack` bounds nested profile data from each public list. Use 10–25 for exploratory research and increase it only when your downstream workflow needs deeper lists.

### Output format

There is one dataset item per Starter Pack. This keeps pack-level context, creator identity, and list metadata together.

When member expansion is enabled, `members` is an array. Each member includes `did`, `handle`, `displayName`, `description`, `avatarUrl`, and `profileUrl`. Flatten this array in your BI tool when you need a profile-per-row export.

### Example output

```json
{
  "query": "technology",
  "packName": "Reuters Technology Coverage",
  "creator": { "handle": "reuters.com", "profileUrl": "https://bsky.app/profile/reuters.com" },
  "listUri": "at://did:plc:.../app.bsky.graph.list/...",
  "membersExpanded": true,
  "scrapedAt": "2026-07-11T00:00:00.000Z"
}
````

### How much does it cost to scrape Bluesky Starter Packs?

This actor charges a $0.005 start event plus one event for each Starter Pack dataset record. Member profiles are nested within the corresponding Starter Pack record, so expansion does not create a separate per-profile event.

| Starter Pack records | Bronze estimate | Free-plan estimate |
| ---: | ---: | ---: |
| 10 | $0.00528 | $0.00533 |
| 50 | $0.00642 | $0.00663 |
| 100 | $0.00784 | $0.00826 |

The Bronze item rate is $0.000028381 and the Free item rate is $0.000032639. Apify shows your applicable tier before a run; estimates exclude any unrelated platform subscription charges.

Start with a 10-item run to validate relevance and estimate your workflow cost.

### Pricing

Pricing is per Starter Pack dataset row, not per nested member. The table above includes the one-time start event, and the current tiered rates shown by Apify at launch remain authoritative.

### Tips for better creator discovery

- Use specific subculture phrases such as `climate journalism` rather than only `climate`.
- Export both the pack description and creator handle; they are useful for relevance review.
- Keep the source AT URIs when creating follow-up enrichment jobs.
- Use the join counters as signals, not as a measure of profile quality.
- Deduplicate member DIDs after flattening several overlapping lists.

### Integrations

#### Lead-research spreadsheet

Schedule topic searches, export the dataset to Google Sheets, flatten `members`, and let a researcher qualify handles by bio and description.

#### Social-listening seed list

Send public profile URLs into a social monitoring workflow. Preserve the originating Starter Pack to attribute why each account was included.

#### Newsletter sourcing

Use pack and curator metadata to find subject experts, then route approved profiles into an editorial contact or citation list.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bluesky-starter-pack-creator-discovery-scraper').call({
  queries: ['technology', 'open source'], maxItems: 50, expandMembers: true, maxMembersPerPack: 20,
});
console.log(await client.dataset(run.defaultDatasetId).listItems());
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/bluesky-starter-pack-creator-discovery-scraper").call(run_input={"queries": ["climate"], "maxItems": 25})
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~bluesky-starter-pack-creator-discovery-scraper/runs?token=$APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"queries":["indie games"],"maxItems":25,"expandMembers":true}'
```

### MCP

Use this actor from Claude Code, Claude Desktop, Cursor, or VS Code through Apify MCP. Add the HTTP MCP server in Claude Code:

```bash
claude mcp add --transport http apify-starter-packs https://mcp.apify.com?tools=automation-lab/bluesky-starter-pack-creator-discovery-scraper
```

For Claude Desktop, Cursor, or VS Code, add this compatible HTTP server configuration in the application's MCP JSON settings:

```json
{
  "mcpServers": {
    "apify-starter-packs": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/bluesky-starter-pack-creator-discovery-scraper"
    }
  }
}
```

If your client only supports stdio MCP, use `npx -y @apify/mcp-server --tools=automation-lab/bluesky-starter-pack-creator-discovery-scraper`. Example prompts: “Find 30 public Bluesky Starter Packs about climate and expand up to 15 members from each” and “Export public game-dev Starter Pack curators with their list AT URIs.”

The actor is especially useful in agent workflows where a researcher needs structured community seeds rather than unbounded post search.

### Public-data and legality

The actor calls public Bluesky API endpoints. You are responsible for ensuring your use complies with applicable law, Bluesky terms, and your own privacy obligations. Do not use public profile data for prohibited profiling, spam, or other harmful activity.

### Reliability and limits

Results reflect what the public API returns at run time. Starter Packs can be renamed, deleted, or have inaccessible lists. Public API rate limits or temporary upstream errors can affect a run. The actor bounds every search and list expansion to keep work predictable.

### Troubleshooting

#### Why did I get fewer records than `maxItems`?

The public search may have fewer matching Starter Packs. Try a broader phrase or add related queries.

#### Why is `members` missing or empty?

Expansion is optional and only applies when a Starter Pack references a readable public list. Check that `expandMembers` is enabled and inspect the log for an individual list failure.

#### What is an AT URI?

An AT URI is the stable protocol identifier used by Bluesky/AT Protocol records. Keep it when you need traceable, source-specific follow-up work.

### FAQ

#### Does this scrape posts, followers, or private accounts?

No. It focuses on public Starter Pack discovery and optional public list-member expansion. Use a profile or post actor for those separate workflows.

#### Is a Bluesky account required?

No. This actor uses public API endpoints without an account or credentials.

#### Can I schedule it?

Yes. Use Apify schedules to repeat the same query set and compare exported results over time.

### Related scrapers

For profile, post, follower, following, or people-search workflows, see the [Bluesky Scraper](https://apify.com/automation-lab/bluesky-scraper). Use this actor when the useful starting point is a public curated Starter Pack or list.

### Changelog

See [the actor changelog](.actor/CHANGELOG.md) for user-visible release notes.

### Support

Include your input (without secrets), run ID, and a short description of the expected public Starter Pack result when requesting support. That makes it possible to reproduce public API behavior quickly.

# Actor input Schema

## `queries` (type: `array`):

Topics, communities, or creator niches to discover (for example: technology, climate, indie games).

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

Total Starter Pack records to save across all queries. Start small while validating your workflow.

## `expandMembers` (type: `boolean`):

Fetch public member profiles from the referenced list for every Starter Pack that has one.

## `maxMembersPerPack` (type: `integer`):

When expansion is enabled, limit public list-member profiles saved inside each Starter Pack record.

## Actor input object example

```json
{
  "queries": [
    "technology"
  ],
  "maxItems": 10,
  "expandMembers": false,
  "maxMembersPerPack": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "technology"
    ],
    "maxItems": 10,
    "expandMembers": false,
    "maxMembersPerPack": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bluesky-starter-pack-creator-discovery-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 = {
    "queries": ["technology"],
    "maxItems": 10,
    "expandMembers": False,
    "maxMembersPerPack": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bluesky-starter-pack-creator-discovery-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 '{
  "queries": [
    "technology"
  ],
  "maxItems": 10,
  "expandMembers": false,
  "maxMembersPerPack": 20
}' |
apify call automation-lab/bluesky-starter-pack-creator-discovery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Starter Pack Discovery Scraper",
        "description": "Discover public Bluesky Starter Packs and optionally expand their curated member profiles for focused creator research.",
        "version": "0.1",
        "x-build-id": "aArN4YyYUhbfYLQ0X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bluesky-starter-pack-creator-discovery-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bluesky-starter-pack-creator-discovery-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/automation-lab~bluesky-starter-pack-creator-discovery-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bluesky-starter-pack-creator-discovery-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/automation-lab~bluesky-starter-pack-creator-discovery-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bluesky-starter-pack-creator-discovery-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Starter Pack search queries",
                        "minItems": 1,
                        "type": "array",
                        "description": "Topics, communities, or creator niches to discover (for example: technology, climate, indie games).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum Starter Packs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Total Starter Pack records to save across all queries. Start small while validating your workflow.",
                        "default": 10
                    },
                    "expandMembers": {
                        "title": "Expand curated list members",
                        "type": "boolean",
                        "description": "Fetch public member profiles from the referenced list for every Starter Pack that has one.",
                        "default": false
                    },
                    "maxMembersPerPack": {
                        "title": "Maximum members per Starter Pack",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "When expansion is enabled, limit public list-member profiles saved inside each Starter Pack record.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
