Bluesky Monitor & Scraper — Posts, Keywords, Followers

Bluesky monitor and scraper: track keywords, hashtags and accounts on Bluesky and get posts, profiles and follower lists as flat JSON or CSV from the public AT Protocol API, with no login or proxies. Schedule it with Only new since last run and it emits just the posts or followers that appeared since the previous run, ready for a webhook.

What it does

This Actor pulls public data out of Bluesky through the official, unauthenticated AT Protocol API (the public.api.bsky.app AppView, with its origin api.bsky.app as fallback for post search) and writes it as flat, analysis-ready records: posts matching keywords or hashtags, full profiles with follower / following / post counts, the posts of specific accounts, and complete follower and following lists. Opt-in record modes add the conversation around a single post (every reply in its thread, the posts quoting it, the accounts that liked or reposted it), the posts of any custom feed or list, and the members of a list or starter pack. Every record is normalized the same way regardless of mode, so you can drop the dataset straight into a spreadsheet, a BI tool, a CRM or an LLM pipeline. Apify gives you the results as JSON, CSV, Excel, an API endpoint, webhooks, or through the Apify MCP server for AI agents, at no extra cost.

It is built for brand and reputation monitoring, social listening, competitor and influencer research, audience analysis, and journalists or researchers who need Bluesky data without writing AT Protocol code. Turn on Only new since last run and schedule the Actor, and it becomes a monitor that emits only posts, followers or profile changes that appeared since the previous run and can POST them to your webhook.

No login, no API key, no proxies, no browser: it talks to the same public endpoints the Bluesky app uses, politely rate-limited.

For the same brand, sponsor or topic in another public medium, Podcast RSS Scraper — Episodes, Transcripts & Apple Podcasts tracks episode titles, show notes and transcripts the same pay-per-event way.

Why this Actor

	This Actor	Typical scraper in this category	Do it yourself
Data sources covered	Bluesky's public AT Protocol AppView (public.api.bsky.app, with the origin host as fallback for post search): posts, profiles, author feeds, followers, following, actor search, thread replies, quote posts, likes, reposts, custom feeds, list feeds, list and starter-pack members	One job per Actor (posts only, or followers only), so a monitoring setup needs several Actors and several bills	The XRPC endpoints, one client per method, with cursor pagination and lexicon changes to follow
Modes	Fourteen: six core modes (searchPosts, authorFeed, profiles, followers, following, searchActors) and eight opt-in record modes (postThread, quotes, likedBy, repostedBy, customFeed, listFeed, listMembers, starterPack), each with Only new since last run	One or two; new-only monitoring is rare	Keep seen keys yourself and stop paging in the right place
Output fields	One flat record per post, profile or follower: engagement counts, embeds, reply and repost context, labels, URLs, fetchedAt; the same shape in every mode	Nested API payloads passed through, or a different subset per Actor	Whatever you flatten from the lexicon objects
Pricing unit	Per post, per profile, per follower record and per feed page requested; an error item costs the same as the record it replaces	Per result, sometimes with a per-run fee or a subscription	Your time plus compute; the API itself is free
Proxies or browsers needed	None	Some need proxies for post search or a logged-in session	None for the public API, but post search from a datacenter is capped
Agent / MCP ready	Yes: pay-per-event, limited permissions, pin link, prompts and a call example below	Sometimes	You write and host the tool definition
Limits	Post search returns at most 100 posts per query from datacenter networks; time budget per query; only data visible when logged out	Varies; search caps are often undocumented	The same CDN limits apply to your code

• One Actor covers the whole listening loop: who posted about a topic, who they are, who follows them and what changed since yesterday, with one record shape and one state store.
• Monitor mode stops paging as soon as it reaches known records, so a quiet keyword costs one feed page rather than a crawl of the history.
• Every page requested is a visible charge, including empty pages and failed requests, so a run's cost is predictable and nothing is billed in bulk at the end.
• A blocked search or an unknown handle becomes a charged error item with a code (SEARCH_FORBIDDEN, PROFILE_NOT_FOUND, …), never a failed run and never a silent gap.
• The quick-start input is the Store's daily automated test, so the Actor is verified every day against the live API.

How to use

1. Pick a Mode and enter your Queries, one per line: keywords or hashtags for searchPosts / searchActors, handles (bsky.app), DIDs or profile URLs for profiles, authorFeed, followers and following, and record URLs for the record modes (a post URL for postThread, quotes, likedBy, repostedBy; a custom feed URL for customFeed; a list URL for listFeed and listMembers; a starter pack URL for starterPack). Copy the URL from the bsky.app address bar; at:// URIs work too.
2. Optionally set Max results, Sort and Since (for post modes), and a Webhook URL. For scheduled monitoring enable Only new since last run.
3. Click Start. Records appear in the dataset as they are found; download them or connect via API, integrations or MCP.

Quick start input

The same input the Store runs in its daily automated test, so it is cheap and always available; paste it into the JSON tab of the input form or send it as the body of an API or MCP call:

{
  "mode": "authorFeed",
  "queries": [
    "bsky.app"
  ],
  "maxResults": 20,
  "sort": "latest"
}

Ready-to-run inputs

Inputs you can paste as they are (replace the <handle> and <id> placeholders); each validates against the input schema.

Keyword search, newest first, since a date

{
  "mode": "searchPosts",
  "queries": ["apify", "\"web scraping\""],
  "maxResults": 200,
  "sort": "latest",
  "since": "2026-10-20"
}

Hashtag watch on a schedule: only posts not seen before, pushed to a webhook

{
  "mode": "searchPosts",
  "queries": ["#webscraping", "#opensource"],
  "maxResults": 200,
  "sort": "latest",
  "onlyNewSinceLastRun": true,
  "stateStoreName": "bluesky-hashtags",
  "webhookUrl": "https://example.com/hooks/bluesky"
}

Follower list of one account; later runs return only new followers

{
  "mode": "followers",
  "queries": ["bsky.app"],
  "maxResults": 5000,
  "onlyNewSinceLastRun": true,
  "stateStoreName": "bluesky-followers-bsky-app"
}

Every reply to a post, then only new replies on later runs (conversation listening)

{
  "mode": "postThread",
  "queries": ["https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l"],
  "maxResults": 1000,
  "onlyNewSinceLastRun": true,
  "stateStoreName": "bluesky-thread-launch"
}

Who liked a post, and the posts that quote it (two runs)

{ "mode": "likedBy", "queries": ["https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l"], "maxResults": 500 }

{ "mode": "quotes", "queries": ["https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l"], "maxResults": 200 }

Posts of a community custom feed, and the members of a starter pack

{ "mode": "customFeed", "queries": ["https://bsky.app/profile/bsky.app/feed/whats-hot"], "maxResults": 100 }

{ "mode": "starterPack", "queries": ["https://bsky.app/starter-pack/<handle>/<id>"], "maxResults": 150 }

Record modes (opt-in)

Mode	Query	Bluesky API method	Records	Order and monitor stop
postThread	post URL	app.bsky.feed.getPostThread (one request returns the whole reply tree)	post, one per reply below the post (isReply, replyParentUri, replyRootUri); the post itself is not repeated	thread order, depth-first; monitor mode emits replies not seen before
quotes	post URL	app.bsky.feed.getQuotes	post, one per quote post (quotedPostUri points at your post)	newest first; stops at the first known quote
likedBy	post URL	app.bsky.feed.getLikes	follower record with type: "liker", subjectUri (the post) and interactedAt (when the like was made)	newest first; stops at the first known liker
repostedBy	post URL	app.bsky.feed.getRepostedBy	follower record with type: "reposter" and subjectUri	newest first; stops at the first known reposter
customFeed	custom feed URL	app.bsky.feed.getFeed	post	the feed's own order; monitor mode stops after two pages with nothing new
listFeed	list URL	app.bsky.feed.getListFeed	post (posts and reposts by the list's members)	newest first; stops at the first known post
listMembers	list URL	app.bsky.graph.getList, then getProfiles	full profile with counts	list order; monitor mode emits new members
starterPack	starter pack URL	app.bsky.graph.getStarterPack, then as listMembers	full profile with counts	as listMembers

A URL with a handle (/profile/bsky.app/...) costs one extra, uncharged handle lookup per distinct handle in a run (com.atproto.identity.resolveHandle); a DID in the URL skips it. Custom feeds that need a logged-in viewer (personalized "for you" feeds) answer with an error item. since filters posts by creation date in every post mode.

Input

Field	Type	Required	Description
mode	string	yes	authorFeed (default), profiles, followers, following, searchActors or searchPosts; opt-in record modes postThread, quotes, likedBy, repostedBy, customFeed, listFeed, listMembers, starterPack
queries	string[]	yes	Keywords / hashtags, handles / DIDs / profile URLs, or record URLs / at:// URIs depending on mode
maxResults	integer	no	Upper bound on dataset items across all queries (default 200); searchPosts additionally stops at 100 posts per query, see Limits
sort	string	no	latest (default) or top; searchPosts only
since	string	no	ISO date or datetime; only posts created on or after it (searchPosts, authorFeed, postThread, quotes, customFeed, listFeed)
onlyNewSinceLastRun	boolean	no	Emit only records not seen by previous runs (default false)
maxSecondsPerQuery	integer	no	Time budget per query in seconds (default 900, 30 to 3600); see "Limits and fair use"
stateStoreName	string	no	Named key-value store for the monitor memory (default bluesky-monitor-state)
webhookUrl	string	no	POST target for the run summary and up to 100 records

Output example

Post record (searchPosts, authorFeed, postThread, quotes, customFeed, listFeed):

{
  "type": "post",
  "query": "apify",
  "uri": "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3l6oveex3ii2l",
  "cid": "bafyreihqbw4xqgzvrjj7mcjf4wq6zq4b5j6m3i3f6zkr3vfyhdgq4i2z3q",
  "rkey": "3l6oveex3ii2l",
  "authorHandle": "bsky.app",
  "authorDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "authorDisplayName": "Bluesky",
  "authorAvatar": "https://cdn.bsky.app/img/avatar/plain/did:plc:z72i7hdynmk6r22z27h6tvur/bafkreihagr2c...@jpeg",
  "text": "We shipped a new Apify integration today! Try the open API: https://docs.bsky.app",
  "createdAt": "2026-10-15T18:02:11.482Z",
  "indexedAt": "2026-10-15T18:02:12.000Z",
  "likeCount": 310,
  "repostCount": 40,
  "replyCount": 12,
  "quoteCount": 5,
  "langs": ["en"],
  "hasImages": true,
  "hasVideo": false,
  "embedUrls": ["https://cdn.bsky.app/img/feed_fullsize/plain/did:plc:z72i7hdynmk6r22z27h6tvur/bafkreia@jpeg"],
  "externalUrl": null,
  "quotedPostUri": null,
  "quotedPostUrl": null,
  "isReply": false,
  "replyParentUri": null,
  "replyRootUri": null,
  "isRepost": false,
  "repostedByHandle": null,
  "repostedByDid": null,
  "labels": [],
  "postUrl": "https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l",
  "fetchedAt": "2026-10-16T12:40:32.064Z"
}

Profile record (profiles, searchActors, listMembers, starterPack):

{
  "type": "profile",
  "query": "bsky.app",
  "did": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "handle": "bsky.app",
  "displayName": "Bluesky",
  "description": "official Bluesky account (check username👆)\n\nBugs, feature requests, feedback: support@bsky.app",
  "avatar": "https://cdn.bsky.app/img/avatar/plain/did:plc:z72i7hdynmk6r22z27h6tvur/bafkreihagr2c...@jpeg",
  "banner": "https://cdn.bsky.app/img/banner/plain/did:plc:z72i7hdynmk6r22z27h6tvur/bafkreichzyov...@jpeg",
  "followersCount": 15123456,
  "followsCount": 20,
  "postsCount": 1234,
  "createdAt": "2023-04-12T04:53:57.057Z",
  "indexedAt": "2026-10-01T00:00:00.000Z",
  "labels": [],
  "profileUrl": "https://bsky.app/profile/bsky.app",
  "fetchedAt": "2026-10-16T12:41:04.001Z"
}

Follower records (followers, following) have type follower or following, subjectHandle / subjectDid (the account you asked about), and the follower's did, handle, displayName, description, avatar, createdAt, profileUrl. Bluesky's follower lists do not include per-follower counts; run the profiles mode on the handles you care about to enrich them.

Liker and reposter records (likedBy, repostedBy) have the same fields with type liker or reposter, plus subjectUri (the post) and, for likers, interactedAt; subjectDid is the post author's DID and subjectHandle the handle from your URL (the DID when the URL used one):

{
  "type": "liker",
  "query": "https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l",
  "subjectDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "subjectHandle": "bsky.app",
  "did": "did:plc:follower000000000000000001",
  "handle": "alice.bsky.social",
  "displayName": "Alice",
  "description": "I like protocols",
  "avatar": "https://cdn.bsky.app/img/avatar/plain/did:plc:follower000000000000000001/avatar@jpeg",
  "createdAt": "2024-11-10T03:00:00.000Z",
  "indexedAt": "2026-09-01T00:00:00.000Z",
  "labels": [],
  "profileUrl": "https://bsky.app/profile/alice.bsky.social",
  "fetchedAt": "2026-11-08T12:00:00.000Z",
  "subjectUri": "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3l6oveex3ii2l",
  "interactedAt": "2026-11-08T10:40:24.597Z"
}

Error items look like { "type": "error", "query": "...", "mode": "profiles", "error": "PROFILE_NOT_FOUND", "errorMessage": "..." } (INVALID_HANDLE, PROFILE_NOT_FOUND, SEARCH_FORBIDDEN, RATE_LIMITED, FETCH_FAILED; in the record modes also INVALID_URI for a query that is not a URL of the right kind and RECORD_NOT_FOUND for a deleted or unknown post, feed, list or starter pack) and are charged at the same rate as a successful record, because the work to discover the problem was done.

If the output saves you time, a review on the Store page helps other buyers find this Actor; the Store invites you to leave one after you have run it a few times.

Alerts and delivery

With Only new since last run the Actor is a monitor; this is how its output reaches you.

• Schedule in the Console. Save the input as a Task, then create a schedule under Schedules (hourly, daily or a cron expression) and attach the Task. Keep one stateStoreName per schedule so two cadences on the same query do not share a memory.
• The Actor's own webhook. Set webhookUrl and the Actor POSTs one JSON document at the end of every run, even one that found nothing (10 second timeout, two retries; a failed delivery is recorded as webhookDelivered: false in the SUMMARY record and never fails the run). The body is the run summary (actor, runId, mode, queries, produced, maxResults, onlyNewSinceLastRun, charges, truncated, limitReached, startedAt, finishedAt, durationSec) plus items: the first 100 records of the run in dataset shape, which in monitor mode are the new posts, followers or changed profiles. Larger runs continue in the dataset.
• Apify run webhooks. On the Actor's Integrations tab add a webhook for run events such as ACTOR.RUN.SUCCEEDED, ACTOR.RUN.FAILED or ACTOR.RUN.TIMED_OUT; Apify POSTs the run id and the default dataset id to your URL, which is all your own code needs to fetch the items.
• Slack, Make, Zapier, Google Sheets, email. The same Integrations tab lists Apify's ready-made integrations: a Slack message when a run finishes, Make and Zapier modules that start runs and read the dataset, an export of each run's dataset to a Google Sheet, and an email notification. They are configured per Actor or per task, without code.
• API and dataset endpoints. Start a run with POST https://api.apify.com/v2/acts/owlabee~bluesky-monitor/runs, read the newest results with GET https://api.apify.com/v2/acts/owlabee~bluesky-monitor/runs/last/dataset/items?format=json (also csv or xlsx, and fields to pick columns), or read any run's dataset at https://api.apify.com/v2/datasets/<datasetId>/items. For short runs run-sync-get-dataset-items starts the run and returns the items in one call.

Pricing

Pay per event. You only pay for the records the Actor produces; set a maximum cost per run in the run options to cap spend.

Event	Price	Charged in
Post (post-scraped)	$0.0005	searchPosts, authorFeed, postThread, quotes, customFeed, listFeed
Profile (profile-scraped)	$0.002	profiles, searchActors, listMembers, starterPack
Follower record (follower-scraped)	$0.0005	followers, following, likedBy, repostedBy
Feed page (feed-page-fetched)	$0.001	Every page requested from the Bluesky API in authorFeed, searchPosts, followers, following, searchActors, quotes, likedBy, repostedBy, customFeed, listFeed and listMembers (up to 100 posts, follows, likes, actors or members per page), one postThread request per post (all its replies) and one starter pack lookup, including pages with nothing new, empty pages and a request that fails; profiles mode lookups are not charged a page
Actor start	$0.00005	Apify platform event, every run

Examples: 1,000 posts from one account ≈ $0.50 + 10 feed pages $0.01 ≈ $0.51; 1,000 full profiles ≈ $2.00; 10,000 followers ≈ $5.00 + 100 feed pages $0.10 ≈ $5.10; all 300 replies to one post ≈ $0.15 + 1 thread request $0.001 ≈ $0.15; 1,000 likers of a post ≈ $0.50 + 10 pages $0.01 ≈ $0.51. Error items cost the same as the record they stand in for. With Only new since last run, the first (baseline) run charges for every record it emits; later runs charge only for new records, so a quiet keyword costs only the page requests it needed (typically one $0.001 page) and the Actor start fee.

Store pricing discounts: users on the Scale plan (Silver) pay 10% less per event, Business (Gold) 15–20% less.

Limits and fair use

• Requests are rate-limited to about 2 per second against the public Bluesky AppView, with exponential backoff on 429 / 5xx. One request returns up to 100 posts or followers (25 profiles), so 10,000 followers take roughly one minute.
• searchPosts is backed by Bluesky's search index; very broad terms are capped by the index itself and top ordering is Bluesky's relevance ranking. Use since and latest for exhaustive recent coverage.
• Post search is capped at 100 posts per query from datacenter networks. The CDN in front of public.api.bsky.app answers app.bsky.feed.searchPosts with an HTML 403 page from datacenter networks (Apify's included) while every other method is served normally. The Actor recognizes that page and retries the call on the AppView origin api.bsky.app, the same unauthenticated service that Bluesky documents alongside the public host. The origin serves the first page of results (up to 100 posts per query, newest first with latest, best first with top) but refuses cursor pagination without a login, so each query stops there; with since, narrower keywords, several queries, or Only new since last run on a schedule you keep up with the newest matches. Only if both hosts refuse does the run continue with one SEARCH_FORBIDDEN error item per query (charged as one post) instead of failing. The default and daily-test mode is authorFeed.
• Thread size. postThread asks for the whole reply tree in one request (depth 1000, the API maximum); the AppView itself bounds the answer (a 547-reply post returned 314 replies in 740 KB on 2026-11-08), so very large threads are returned as far as Bluesky serves them logged out. For more of a viral thread, also run quotes and searchPosts on its keywords.
• Only public data is accessed: posts and profiles whose authors opted out of logged-out visibility (!no-unauthenticated label) may be partially or entirely absent, exactly as on the public web.
• Time budget per query. Each query (one handle or search term; for profiles one batch of up to 25 handles) gets maxSecondsPerQuery seconds (default 900) and is cut off earlier when it has produced no charged record for 60 seconds (a stalling, timing-out or blocking API). Every request, retries included, is limited to 20 seconds and a Retry-After longer than 10 seconds is not waited for. A cut-off query keeps the records already collected (truncated in the run summary); a query that collected nothing becomes one TIME_BUDGET error item, charged like every error item. In monitor mode a query also stops after two consecutive pages with nothing new, so deleted or pruned seen records never page through the whole history.
• Memory: 256 MB is plenty. Default run memory is 512 MB.
• Monitor memory keeps the most recent 10,000 record keys per query in your state store; delete that store (or change stateStoreName) to reset the baseline.

Related Actors

Other pay-per-event Actors from the same account, all limited-permission and agent-friendly:

• Podcast RSS Scraper — Episodes, Transcripts & Apple Podcasts — track podcast episodes and transcripts for the same brand, sponsor or topic mentions.
• Website Change Monitor — Sitemap Monitor & Page Diff — get a change feed for the websites of the accounts you follow.
• SPF, DMARC & DKIM Checker — Bulk Domain WHOIS, DNS & SSL — enrich the domains linked from Bluesky profiles with WHOIS, DNS, email security and tech stack.

Guide and code examples

• Guide: Bluesky Monitor: Posts, Hashtags and Followers as JSON, covering the source, its fields and limits, and curl and MCP examples.
• Runnable examples (curl, Python, Node.js and an MCP config): owlabee/owlabee on GitHub.

Use from AI agents (MCP)

Pin this Actor in the Apify MCP server with one link: https://mcp.apify.com?tools=owlabee/bluesky-monitor, or let the agent find it with the search-actors tool. It is pay-per-event with limited permissions, so agents can discover it, inspect the input schema with fetch-actor-details and pay per run through agentic payments. Prompts that map directly onto the input:

1. "Find the 50 most recent Bluesky posts mentioning 'Apify' or '#webscraping' from the last 7 days and summarize the sentiment and the most-liked ones."
2. "Get the full Bluesky profiles (follower count, post count, bio) for these handles: bsky.app, atproto.com, jay.bsky.team, and rank them by followers."
3. "Check which accounts started following ourcompany.bsky.social since the last check and send the new ones to our webhook." (run with mode=followers, onlyNewSinceLastRun=true on a schedule)

The agent receives the same dataset records shown in the output example above.

To call it from an agent that already has the Apify MCP server connected, copy this tool call and change only the input object (shown with the quick-start input; any input that validates in the Console works here too). The server returns the run's dataset items, and its per-call maximum total charge (maxTotalChargeUsd) caps spend the same way the run option does in the Console.

{
  "tool": "call-actor",
  "arguments": {
    "actor": "owlabee/bluesky-monitor",
    "input": {
      "mode": "authorFeed",
      "queries": [
        "bsky.app"
      ],
      "maxResults": 20,
      "sort": "latest"
    }
  }
}

FAQ

Does this need proxies, a login or an API key? No. It uses Bluesky's public, unauthenticated XRPC endpoints over plain HTTPS from Apify's standard datacenter infrastructure.

How is cost controlled? Set maxResults and the run's maximum total charge. Each record is charged the moment it is saved, and the Actor stops cleanly when either limit is reached; nothing is charged in bulk at the end.

How does "Only new since last run" work? The Actor keeps, per mode and query, the keys of records it already emitted in the named key-value store stateStoreName. On the next run it pages newest-first, emits only unseen posts / followers / changed profiles, and stops as soon as it reaches already-known records. Profiles are re-emitted only when the handle, name, bio, avatar or any count changed (changedFields tells you what).

Can I get the replies, quotes or likes of one post? Yes: switch Mode to postThread, quotes, likedBy or repostedBy and paste the post's bsky.app URL. With Only new since last run on a schedule, each run returns only the replies, quotes, likers or reposters that appeared since the previous one. These modes are opt-in: runs that keep the default mode behave and cost exactly as before.

Can I search hashtags or exact phrases? Yes: #opensource, "exact phrase", and Bluesky's search operators such as from:handle, lang:en or domain:example.com are passed through to the search index. Each query returns at most its first 100 matches per run (see Limits), so split broad topics into several queries or narrow them with since and operators.

Can an AI agent use this? Yes; see "Use from AI agents (MCP)" above for the pin link and example prompts. Schedules and webhooks work the same way from the Console or the API.

What happens on errors? Bad handles, unknown profiles, a blocked search endpoint (SEARCH_FORBIDDEN) or temporary API failures produce error items with a clear code instead of failing the whole run; genuinely unusable input (empty queries, invalid since) fails fast before any paid work.

Can I try it for free? Yes. The Apify free plan comes with monthly platform credit, and the quick-start input above costs a few cents per run, so you can test it on your own inputs before paying anything.

How do I find this Actor again? Bookmark it on the Store page (the bookmark icon next to the title); bookmarked Actors are listed in your Console, and the Store page shows new versions as they ship.

Support

Questions, bugs or a source you'd like added? Open an issue on the Actor's Issues tab, or email jacob@owlabee.com.

Changelog

• 2026-11-08 — Eight opt-in record modes on the same public AppView: postThread (every reply to a post), quotes, likedBy, repostedBy, customFeed, listFeed, listMembers and starterPack, all with monitor mode and the existing events. Liker and reposter records add subjectUri (and interactedAt for likes). Default mode, inputs, records and prices are unchanged.
• 2026-10-27 — README: comparison table, ready-to-run inputs for keyword, hashtag and follower modes, alerts and delivery, MCP call example, changelog.
• 2026-10-25 — Pricing round: the feed page became its own work-based event (charged for every page requested, empty or failed), event titles pluralized, Store discount tiers for the Scale and Business plans described; applied in the Console on 2026-10-26.
• 2026-10-23 — Time budget per query (maxSecondsPerQuery), 20 second request deadline including retries, idle cut-off, two-stale-page stop in monitor mode, charged TIME_BUDGET error items, worst-case margin tests. Listing: new title, SEO fields, MCP section, quick start, task examples.
• 2026-10-18 — Published on the Store with its task examples.
• 2026-10-17 — Post search falls back to the AppView origin when the CDN refuses datacenter requests; one SEARCH_FORBIDDEN error item per query only if both hosts refuse.
• 2026-10-16 — First release: six modes, monitor memory per query, end-of-run webhook with a record sample.

Legal

The Actor reads only data that Bluesky publishes through its public API. Bluesky's Developer Guidelines ask that every service can delete content a user asked to have deleted: results live only in your own Apify storage, the Actor keeps no copy outside your run's storage and your named state store, and if you keep exported posts, honor deletions (re-run the query, or drop records that no longer resolve). Not affiliated with or endorsed by Bluesky Social, PBC; the name identifies the platform the public records come from. Respect Bluesky's terms, the AT Protocol community guidelines and applicable privacy law (GDPR, CCPA) when storing or processing personal data such as handles, names and bios. This Actor is not a consumer reporting agency and its output must not be used for employment, credit, insurance, housing or tenant screening decisions.