Mattering Automations Bluesky integration
Connect Bluesky to Mattering Automations: timelines, search, threads, profiles, the follower graph, lists, notifications, publishing and the raw record surface as workflow steps, authenticated with an app password you create in the Bluesky settings rather than your account password.
The Mattering Automations Bluesky integration puts the AT Protocol XRPC API on your automation canvas: read the home timeline, an account's posts, a post thread, network search results, custom feeds and list feeds, hydrate posts and profiles in batches, walk followers and following, read notifications, publish posts, likes, reposts, follows and blocks, mute accounts and threads, and reach every other record type through a generic repository surface. Forty eight nodes in total, twenty nine that read and nineteen that act.
The credential is the part worth reading before you start. Bluesky issues no API keys at all, so this integration authenticates with an identifier and an app password: a separate credential you create in the Bluesky settings and paste into Add Connector once. An app password is not the account password: Bluesky describes it as the way to sign in to other Bluesky clients without giving full access to your account or password, and you can delete one later without disturbing your own login. Mattering exchanges those two values for a session behind the scenes, so no node ever asks you about tokens.
Two things about this network shape everything you build on it, and both are easier to read now than to discover later. Bluesky is public and federated, so a record you create is copied by mirrors within seconds and no delete can un-fetch those copies or recall the notification the write already sent. And Bluesky runs no sandbox: it shut its federation sandbox down in 2024 and put no staging environment in its place, so a post written by a node is a real post. Thirteen nodes are classed destructive for those reasons, and this guide ends with the complete node reference.
Before you start
- A Bluesky account. Any account will do and no paid plan or developer tier is involved: Bluesky's API needs no key provisioning, no application registration and no review process, and creating an app password is a settings screen rather than a plan feature.
- An app password created in that account's Bluesky settings, under Settings, Privacy and security, App passwords. Bluesky shows the value once and says you will not be able to view it again, so copy it before you close the dialog. Leave the option that allows access to your direct messages switched off: this integration does not build the direct-message surface, so it does not need that access.
- A decision about which Bluesky account the workflows act as. Every node runs as that account: posts are attributed to it, its likes and follows are public records, and unattended automations keep running on it. A dedicated account is usually a better idea than an individual's personal login.
- A throwaway account if you intend to test anything that writes. Bluesky runs no sandbox, so a test post is a real public post. Reads are safe to exercise on a live account.
- The service host, only if the account is self-hosted. An ordinary account on bsky.social needs nothing here. A self-hosted PDS works unchanged, and the host must be https, because an app password sent in the clear is interceptable.
- An account without two-factor email confirmation, if the connection has to run unattended. An account with email 2FA cannot complete an app-password login without a human supplying a code, and Test Connection names that specific case rather than reporting a generic bad credential.
- A Mattering workspace with access to the Automations app.
Create a Bluesky app password
There is no API key to find, no developer portal to register in and nothing to wait for. What you create is an app password, which Bluesky describes as the way to sign in to other Bluesky clients without giving full access to your account or password. You can delete one later without disturbing your own login. This is the only Bluesky credential this integration will accept, and it is never the account password.
Connect Bluesky to Mattering
Verify it works
Open any automation canvas and check the palette: a Bluesky section should list the read and action nodes. Drop Bluesky: Get Session onto the canvas and run a test step. It takes no configuration at all and it answers the question that matters before anything writes: which account this connection acts as, whether that account is active, and the DID every other node falls back to when a repository or actor field is left blank. It is also the node to run first whenever another node returns an unexpected 401.
Now run Bluesky: Get Timeline without changing anything. This is the step that proves more than the credential does. The connection test only exercises the session exchange, and every node in this integration authenticates at that same step, so a passing test says nothing about whether reads work. A timeline that comes back with posts confirms that your PDS is proxying app.bsky requests to the AppView correctly, which is the other half of the plumbing.
Optionally run Bluesky: Get Profile against a handle you know, and look at the viewer block in the response rather than the profile fields. viewer.following holds the AT-URI of your own follow record when you follow that account and is blank when you do not, and viewer.blocking is the same for blocks. Those two fields are where Bluesky: Unfollow Account and Bluesky: Unblock Account get their input, so seeing them populated is what tells you the undo half of this integration will work. Everything in this verify path is read-only and safe to re-run.
Node reference
48 nodes, generated from the connector itself so this reference always matches what ships.
Read and query nodes 29
Bluesky: Describe Repository
bluesky_describe_repo
Describe a repository: its handle, its DID, its DID document, and the list of record collections it holds at least one record of (data.collections[]). Leave the repository blank for the connected account. This is the node that populates the collection pickers on the record nodes below.
Bluesky: Get Author Feed
bluesky_get_author_feed
Read one account's public posts, newest first. This is the node for watching a competitor, a customer or your own account. The filter decides whether replies, media posts or self-threads are included, and it changes the result set substantially - a mentions monitor almost always wants posts_no_replies.
Bluesky: Get Custom Feed
bluesky_get_feed
Read a custom feed (a feed generator) by its AT-URI: the same hydrated shape as the timeline, but curated by whoever runs the feed. Feeds are third-party services, so a feed whose generator is offline returns an UnknownFeed error rather than an empty list; Bluesky: Get Feed Details reports whether it is online before you depend on it.
Bluesky: Get Feed Details
bluesky_get_feed_generator
Describe one custom feed and, importantly, report whether it is actually working: data.isOnline says the generating service responded recently and data.isValid says it is compatible with its own declaration. Check these before a scheduled workflow starts depending on a feed somebody else operates.
Bluesky: Get Followers
bluesky_get_followers
List the accounts following a given account, at data.followers[], with the subject account echoed at data.subject. Walk the cursor to page through a large following; each page carries at most 100 accounts.
Bluesky: Get Following
bluesky_get_follows
List the accounts a given account follows, at data.follows[]. Each row is a profile view whose viewer.following field holds the AT-URI of your own follow record when you follow them too, which is what Bluesky: Unfollow Account consumes.
Bluesky: Get List Feed
bluesky_get_list_feed
Read the combined posts of everyone on a curation list, newest first. This is the cheapest way to watch a fixed set of accounts with one call instead of one call per account, and the list can be edited in the Bluesky app without touching the workflow. Moderation lists have no feed; point this at a curation list.
Bluesky: Get List Members
bluesky_get_list
Read one list's details plus the accounts on it. The list itself is at data.list and the members are at data.items[], where each item carries its own record URI and the member's profile at data.items[].subject.
Bluesky: Get Post Likes
bluesky_get_likes
List the accounts that liked a post. Each row carries the liking account at data.likes[].actor plus when the like was created and indexed, so this is the node for turning engagement into a list of people rather than a number.
Bluesky: Get Post Quotes
bluesky_get_quotes
List the posts that QUOTE a post, hydrated in full at data.posts[]. A quote carries commentary a repost does not, so this is usually the more interesting half of an amplification report - and the half a sentiment check should actually read.
Bluesky: Get Post Reposters
bluesky_get_reposted_by
List the accounts that reposted a post, at data.repostedBy[]. Quote posts are NOT included here - they are separate records - so pair this with Bluesky: Get Post Quotes for a full picture of who amplified something.
Bluesky: Get Post Thread
bluesky_get_post_thread
Read a post together with its replies and its parents. The response is a recursive tree at data.thread, where each node carries a post and a replies[] array, so a consumer that only walks flat lists will see the root post and nothing else. Replies that are blocked or deleted appear as blockedPost and notFoundPost placeholders rather than disappearing, which is how the thread keeps its shape.
Bluesky: Get Posts
bluesky_get_posts
Hydrate up to 25 posts by AT-URI in one call: author, text, counts, labels, and your own viewer state (data.posts[].viewer.like and .repost hold the AT-URIs of YOUR like and repost records for each post, which is what the un-like and un-repost nodes need). Use this to refresh engagement counts for posts collected earlier rather than re-reading a whole feed.
Bluesky: Get Profile
bluesky_get_profile
Read one account's full profile: display name, description, avatar and banner, follower/following/post counts, and its pinned post. The viewer block is the useful part for workflows - data.viewer.following is the AT-URI of YOUR follow record (blank when you do not follow them), which is exactly what Bluesky: Unfollow Account needs, and data.viewer.blocking is the same for blocks.
Bluesky: Get Profiles
bluesky_get_profiles
Read up to 25 full profiles in one call. Use this to refresh a watchlist's follower counts, or to enrich a list of handles collected elsewhere, without spending one request per account.
Bluesky: Get Record
bluesky_get_record
Read one raw record by repository, collection and record key. The stored value comes back at data.value with its current content hash at data.cid, which is the value you need before overwriting a record safely. An AT-URI is exactly these three parts: at://<repo>/<collection>/<rkey>.
Bluesky: Get Relationships
bluesky_get_relationships
Ask, for up to 30 accounts at once, whether one account follows them and whether they follow back. Each row in data.relationships[] carries `following` and `followedBy` as AT-URIs when the relationship exists and omits them when it does not. Far cheaper than paging a whole follower list to answer 'do we already follow this person'.
Bluesky: Get Session
bluesky_get_session
Report the account this connection is authenticated as: its handle, its DID, whether the account is active, and whether the email is confirmed. The cheapest way to confirm a Bluesky credential works, and the node to run first when another node returns an unexpected 401. The DID it returns is what every other node uses when a repository or actor field is left blank.
Bluesky: Get Timeline
bluesky_get_timeline
Read the connected account's own home timeline: the posts from the accounts it follows, newest first. Each item in data.feed[] wraps a post at data.feed[].post, with the reason it appeared (a repost) at data.feed[].reason and the parent chain at data.feed[].reply when it is a reply.
Bluesky: Get Unread Notification Count
bluesky_get_unread_count
How many unread notifications the connected account has, as a single integer at data.count. Cheap enough to poll on a schedule as a gate: fetch the full list only when this is above zero.
Bluesky: List Blocked Accounts
bluesky_get_blocks
List the accounts the connected account is blocking, at data.blocks[]. Always about the authenticated account - there is no way to read anyone else's block list through the API, although the block RECORDS themselves are public in the repository.
Bluesky: List Feeds By Actor
bluesky_get_actor_feeds
List the custom feeds an account has CREATED, with each feed's AT-URI at data.feeds[].uri. Note this is authorship, not subscription: it does not list the feeds an account has saved or pinned, and there is no endpoint that does.
Bluesky: List Lists
bluesky_get_lists
List the curation and moderation lists an account has created, at data.lists[] with each list's AT-URI, name, purpose and item count. Leave the account blank for your own lists. This is the node every list picker in this connector reads from.
Bluesky: List Muted Accounts
bluesky_get_mutes
List the accounts the connected account has muted, at data.mutes[]. Mutes are PRIVATE and server-side: unlike blocks they are not records, they never federate, and the muted account is never told.
Bluesky: List Notifications
bluesky_list_notifications
Read the connected account's notifications, newest first. Each row names who acted (data.notifications[].author), what they did (.reason), the record they created (.record) and whether it has been marked read (.isRead). Reading does NOT mark anything read: use Bluesky: Mark Notifications Seen for that, which is what makes a poll-then-acknowledge workflow possible.
Bluesky: List Records
bluesky_list_records
List the raw records in one collection of a repository - your own posts, your own likes, your own follows, your list definitions, anything. Returns the stored record values, NOT the hydrated views the app.bsky reads return: a like record here is {subject, createdAt}, with no profile and no post text attached. Use it to walk your own history, and hydrate what you find with Bluesky: Get Posts or Bluesky: Get Profiles.
Bluesky: Resolve Handle To DID
bluesky_resolve_handle
Turn a handle into the account's permanent DID. Worth doing once and storing: a handle is a rented DNS name whose owner can change it, so a workflow keyed on a handle silently starts watching nobody, while a DID never changes. No picker on the handle field, because a handle is something a person types.
Bluesky: Search Accounts
bluesky_search_actors
Search the network for accounts by name, handle or bio text. This is also the node that powers every account picker in this connector: Bluesky has no endpoint that ENUMERATES accounts, so the pickers search as you type rather than listing everything, and show nothing until a term is entered.
Bluesky: Search Posts
bluesky_search_posts
Search the public network for posts. This is the brand-monitoring node: a term, optionally narrowed to an author, a mention, a language, a linked domain, hashtags or a date range. Bluesky documents the query syntax as unspecified and recommends Lucene syntax; it also warns that the cursor may not walk the entire result set, so treat deep pagination as best-effort rather than as a complete export.
Action nodes 19
Bluesky: Block Account
bluesky_block_actor
Block an account from the connected account. BLOCKS ARE PUBLIC IN BLUESKY - the lexicon says so explicitly - so the block record is readable by anyone, including the person blocked. It acts immediately and mutually on VISIBILITY: their replies disappear from your threads, neither account can see the other's posts, and no interaction is delivered either way while it stands. What it does NOT do is change the follow graph - Bluesky's own block implementation notes that follow relationships are unchanged by a block, which is why a rapid block then unblock does not work as a way to remove a follower. The other account is notified of nothing but can see the whole sequence in your repository. Prefer Bluesky: Mute Account for that is really about your own feed being quieter, because a mute is private and reversible.
Bluesky: Create Or Update Record
bluesky_put_record
Write a record at a known key, creating it or REPLACING it whole. This is how a profile is edited: read app.bsky.actor.profile with key 'self', change the fields you want, and put the WHOLE object back. Replacement is total, not a merge: any field you omit is deleted, so an update built from a partial object silently wipes the avatar or the description. There is no version history and no undo - read the record first, and pass its CID as swapRecord so a concurrent edit fails loudly instead of being overwritten.
Bluesky: Create Post
bluesky_create_post
Publish a post from the connected account. IRREVERSIBLE IN THE WAY THAT MATTERS: the post is public the instant it is written and is federated within seconds. Bluesky: Delete Post removes it from your repository and asks the network to drop it, but it cannot un-fetch copies mirrors and archives already took, and it cannot recall the notifications a reply or a mention already sent. This node publishes immediately: there is no scheduling and no sandbox, so a test post is a real post seen by real people. Text is limited to 300 graphemes. To reply, give the post you are replying to and the connector resolves the thread root for you with one extra read.
Bluesky: Create Record
bluesky_create_record
Write any record into the connected account's repository. The escape hatch for record types this connector does not type individually - list definitions, list members, threadgates, starter packs, feed generators. IRREVERSIBLE: the record is public and federates within seconds, and deleting it later cannot un-fetch copies already taken. The record object must carry a $type matching the collection, and the server validates it against the lexicon.
Bluesky: Delete Post
bluesky_delete_post
Delete one of the connected account's own posts. WHAT THIS DOES: removes the record from your repository and emits a delete on the firehose, so Bluesky's own AppView stops serving it and well-behaved mirrors drop it. WHAT IT DOES NOT DO: it cannot un-send the notifications the post already generated, it cannot retrieve copies that archives, screenshots or non-compliant mirrors already hold, and it does not delete the replies other people wrote underneath it. Deleting is one-way. The record cannot be restored, only re-created, and a re-created record gets a NEW record key and a NEW CID, so anything still holding the old AT-URI points at nothing.
Bluesky: Delete Record
bluesky_delete_record
Delete any record from the connected account's repository by collection and key. WHAT IT DOES: removes the record and emits a delete on the firehose, so the AppView stops serving it and compliant mirrors drop it. WHAT IT DOES NOT DO: un-federate copies already fetched, or recall notifications the record already caused. Deleting is one-way. The record cannot be restored, only re-created, and a re-created record gets a NEW record key and a NEW CID, so anything still holding the old AT-URI points at nothing. Pass swapRecord to refuse the delete if the record changed since you read it.
Bluesky: Follow Account
bluesky_follow_actor
Follow an account from the connected account. A follow is a PUBLIC record: it appears on your profile's following list, it sends the other account a notification immediately, and it federates. Unfollowing deletes the record but does not recall that notification, so a follow-then-unfollow loop is visible to the person on the other end and is exactly the pattern Bluesky's community guidelines treat as spam. Accepts a handle or a DID and resolves a handle to its DID first, because the follow record stores a DID. Counts against the per-account write budget of 5,000 points an hour and 35,000 a day, where a create costs 3 points and a delete 1 - roughly 1,666 creations an hour. Loops that write per item should pace themselves.
Bluesky: Like Post
bluesky_like_post
Like a post as the connected account. A like is a PUBLIC record in your repository, not a private signal: it appears in the post's like list, it notifies the author immediately, and it federates. Un-liking deletes your like record but does not recall that notification. Leave the content hash blank and the connector resolves the current one for you. Counts against the per-account write budget of 5,000 points an hour and 35,000 a day, where a create costs 3 points and a delete 1 - roughly 1,666 creations an hour. Loops that write per item should pace themselves.
Bluesky: Mark Notifications Seen
bluesky_update_seen
Move the connected account's notification seen-marker forward, which is what clears the unread badge. Nothing is published and nothing federates - this is private account state - and setting the marker back to an earlier timestamp restores the earlier unread count, which is why it is not classed destructive. It does mark notifications read in the Bluesky app for the human using that account, so a workflow that acknowledges notifications is taking that decision on their behalf.
Bluesky: Mute Account
bluesky_mute_actor
Mute an account for the connected account. Unlike a block, a mute is PRIVATE and server-side: no record is written, nothing federates, the muted account is never told, follows in either direction are untouched, and Bluesky: Unmute Account restores the previous state exactly. This is the right tool for keeping a workflow's feed quiet.
Bluesky: Mute Thread
bluesky_mute_thread
Stop notifications from one conversation and everything replied beneath it, without muting anyone. Private, server-side and fully reversible; the thread stays readable, only the notifications stop.
Bluesky: Remove Like
bluesky_unlike_post
Delete one of the connected account's like records, which un-likes the post. Takes the AT-URI of YOUR LIKE, not of the post: read it from any hydrated post at data.posts[].viewer.like or data.feed[].post.viewer.like, or from the like node's own output. The author's notification is not recalled. Deleting is one-way. The record cannot be restored, only re-created, and a re-created record gets a NEW record key and a NEW CID, so anything still holding the old AT-URI points at nothing.
Bluesky: Remove Repost
bluesky_delete_repost
Delete one of the connected account's repost records, which un-reposts the post. Takes the AT-URI of YOUR REPOST, not of the post: read it from a hydrated post at data.posts[].viewer.repost. The original author's notification is not recalled. Deleting is one-way. The record cannot be restored, only re-created, and a re-created record gets a NEW record key and a NEW CID, so anything still holding the old AT-URI points at nothing.
Bluesky: Repost
bluesky_repost
Repost a post to the connected account's followers. This is a PUBLICATION, not a bookmark: the post appears in your followers' timelines attributed to you, the original author is notified, and it federates immediately. Removing the repost stops it being served but does not un-show it to anyone who already saw it. To add commentary instead, create a post with an app.bsky.embed.record embed (a quote post). Counts against the per-account write budget of 5,000 points an hour and 35,000 a day, where a create costs 3 points and a delete 1 - roughly 1,666 creations an hour. Loops that write per item should pace themselves.
Bluesky: Unblock Account
bluesky_unblock_actor
Delete one of the connected account's block records, which unblocks the account. Takes the AT-URI of YOUR BLOCK RECORD: read it from Bluesky: Get Profile at data.viewer.blocking. Unblocking restores VISIBILITY and interaction between the two accounts. It does not need to restore follows, because a block does not delete them: Bluesky's block implementation leaves the follow graph unchanged, which is also why block then unblock is not a way to drop a follower. Deleting is one-way. The record cannot be restored, only re-created, and a re-created record gets a NEW record key and a NEW CID, so anything still holding the old AT-URI points at nothing.
Bluesky: Unfollow Account
bluesky_unfollow_actor
Delete one of the connected account's follow records, which unfollows the account. Takes the AT-URI of YOUR FOLLOW RECORD, not the account's DID: read it from Bluesky: Get Profile at data.viewer.following, which is blank when you do not follow them. Deleting is one-way. The record cannot be restored, only re-created, and a re-created record gets a NEW record key and a NEW CID, so anything still holding the old AT-URI points at nothing.
Bluesky: Unmute Account
bluesky_unmute_actor
Remove a mute the connected account had placed on another account. Fully reversible and private; nothing federates and the other account is never told either way.
Bluesky: Unmute Thread
bluesky_unmute_thread
Resume notifications from a conversation that was muted. Private and fully reversible.
Bluesky: Upload Blob
bluesky_upload_blob
Upload an image or other file to the connected account's repository and get back a blob reference to embed in a post. Nothing is published by this node and nothing is visible to anyone: an uploaded blob that is never referenced by a record is garbage-collected, which is why this is a reversible write rather than a publication. Paste the whole data.blob value into the embed field of Bluesky: Create Post. The PDS ceiling is 52,428,800 bytes (50 MB); Bluesky's own client applies a much smaller limit to post images, so compress before uploading.
Using the integration
The credential model, and what happens after you paste it
Bluesky has no static API key, so the credential you store is not the credential the API accepts. Your identifier and app password authenticate exactly one call, which returns a session: an access token that every other request carries, a refresh token that buys a new access token without re-sending the app password, and the account's DID and handle. Mattering does that exchange, caches the result per organization and per account, and hands the session to every node in a run, so a workflow with three Bluesky steps logs in at most once. Two design choices in that machinery change what you should do, so they are worth stating plainly. The cache is capped at fifteen minutes regardless of what the token itself claims, which is the reason a revoked app password stops working here promptly rather than at some unpredictable later point. And when a session goes stale mid-workflow, the connector renews it and replays the request exactly once rather than looping, so a genuinely revoked app password surfaces as a clean authentication failure instead of hammering a login endpoint that is itself rate limited.
Why the integration refreshes rather than logging in again
Bluesky rate limits the login endpoint per account rather than per IP, and that single fact drives the renewal design. A fleet of short-lived workers that logged in on every cold start would spend an account's daily login allowance on nothing and lock the connector out for everyone using that credential. Bluesky's own guidance for bots says the same thing in different words: calling login repeatedly in a short period may trigger rate limits, and the advice is to resume a stored session instead. So the renewal ladder tries the refresh token first and only falls back to a full login when the refresh token is dead as well. One consequence is worth knowing rather than discovering: refresh tokens rotate, so a refresh retires the token that was presented, and two processes holding the same one will race with the loser falling back to a login. That is expected and handled, not an error you need to act on. Read Bluesky's rate-limits page for the current numbers; the vendor states outright that its published limits are likely to evolve over time.
Publishing to a public federated network
This is the section to read before you automate anything that writes. A record you create is public the instant it is written, is announced within seconds, and is copied by the AppView, by relays and by any number of independent mirrors and archives. Bluesky: Delete Post removes the record from your repository and emits a delete that well-behaved consumers honour, so Bluesky stops serving it, but it cannot un-fetch copies already taken, it cannot recall the notification the post already generated, and it does not delete the replies other people wrote underneath it. Deleting is also one-way in a second sense: a deleted record cannot be restored, only re-created, and a re-created record gets a new record key and a new content hash, so anything still holding the old AT-URI now points at nothing. Thirteen nodes carry the destructive flag for these reasons. Two of them are deliberate over-classifications and it is worth knowing why: Bluesky: Like Post and Bluesky: Follow Account both have an undo, and both write a public record and fire a notification the undo does not recall. Bluesky's developer guidelines prohibit generating automated or bulk interactions, including any that would cause a notification to a user such as a message, a follow, a like or a reply, and its rate-limits page repeats that bulk or spammy interactions are against the community guidelines. The flag is there to stop a workflow doing that to a stranger by accident.
Writing a post, and the three things that catch people
Bluesky: Create Post publishes from the connected account, and three mechanical facts account for most of the surprises. First, the length limit is 300 graphemes rather than 300 characters, so emoji and many scripts cost one grapheme and several bytes, and a length check written against character counts will disagree with Bluesky. Second, links and mentions are not detected automatically: a URL typed into the text renders as unlinked plain text unless a facet covers it, and facet offsets are byte positions rather than character positions. Third, replies. A reply record has to carry both its immediate parent and the thread root, and a reply whose root is wrong is not an error: the post exists and simply detaches from its thread, where nobody sees it in context. This integration removes that footgun by resolving the root itself when you give it the post being replied to, using one extra read. For an image, run Bluesky: Upload Blob first and paste the blob value it returns into the post's embed field. That node is not classed destructive, and the distinction is real rather than lenient: an uploaded blob that is never referenced by a record is visible to nobody and is garbage collected.
The undo nodes want your record, not the post
This is the single most common mistake in this integration, and it has a simple rule. Bluesky: Remove Like, Bluesky: Remove Repost, Bluesky: Unfollow Account and Bluesky: Unblock Account each delete a record you own, so each wants the AT-URI of your own like, repost, follow or block record rather than the URI of the post or the DID of the account. Those URIs are published as viewer state on every hydrated read, which is why this integration always reads through your session rather than through Bluesky's public unauthenticated read host: viewer.like and viewer.repost arrive on every post returned by Bluesky: Get Posts or Bluesky: Get Timeline, and viewer.following and viewer.blocking arrive on every profile from Bluesky: Get Profile. So the value is a template reference from an upstream node rather than something to look up. Blocking deserves one extra note before you automate it. A block is public and enumerable, and it suppresses viewing and delivery in both directions while it stands, but it does not change the follow graph: Bluesky's own account of its block implementation says follow relationships are not changed by a block, which is why a rapid block then unblock does not work as a way to remove a follower. If what you actually want is a quieter feed rather than a public statement, Bluesky: Mute Account is the right tool, because a mute is private, writes no record, never federates, is never disclosed to the other account and is exactly reversible.
Reading efficiently, and what pagination does not promise
Nearly every list node here takes a limit and a cursor and returns a cursor beside its array, and cursors are opaque server-generated tokens rather than values to construct or store. Two habits keep a workflow inside its budget. Batch where the API lets you: Bluesky: Get Posts hydrates up to 25 posts by URI in one call and Bluesky: Get Profiles does the same for accounts, which beats one request per row; Bluesky: Get Relationships answers the follow question for up to 30 accounts at once rather than paging a follower list. And watch a set of accounts with Bluesky: Get List Feed instead of looping Bluesky: Get Author Feed, since the list can be edited in the Bluesky app without touching the workflow. Two limits on what pagination promises. Bluesky documents that the post search cursor may not necessarily allow scrolling through the entire result set, so treat a deep search walk as best effort rather than as a complete export. And Bluesky: Get Post Thread returns a recursive tree rather than a flat list, where each node carries a post and its own replies array, so a consumer that only walks flat lists sees the root post and nothing else. Blocked and deleted replies come back as placeholders rather than vanishing, which is how the thread keeps its shape.
The repository nodes, and what they reach that the typed nodes do not
Every object in Bluesky is a record in somebody's repository, which is what lets forty eight nodes cover an API with far more endpoints than that. Bluesky: List Records walks one collection of a repository, Bluesky: Get Record reads a single record, and Bluesky: Create Record, Bluesky: Create Or Update Record and Bluesky: Delete Record write ones this integration does not type individually, including list definitions, list members, threadgates, postgates and feed generators. Bluesky: Describe Repository reports which collections a repository actually holds at least one record of, and it is what populates the collection pickers. Two cautions. These nodes return stored records rather than hydrated views, so a like record is a subject and a timestamp with no profile or post text attached, and you hydrate what you find with Bluesky: Get Posts or Bluesky: Get Profiles. And Bluesky: Create Or Update Record replaces a record whole rather than merging: any field you omit is deleted, which is how an update built field by field silently wipes a profile's avatar. Read the record first, change what you meant to change, put the whole object back, and pass the content hash you read as swapRecord so a concurrent edit fails loudly instead of being overwritten.
There are no triggers, so schedule and poll
This integration has no trigger nodes: Bluesky's real-time surface is the firehose, which is a websocket event stream and a different piece of infrastructure rather than an HTTP endpoint, so nothing here listens for a push. Bluesky workflows therefore run on a schedule and poll, and the cheap pattern is a gate. Bluesky: Get Unread Notification Count returns a single integer, so a schedule can check it frequently and only run Bluesky: List Notifications when it is above zero. Reading notifications does not mark anything read, which is what makes a poll then acknowledge workflow possible in the first place, and Bluesky: Mark Notifications Seen is the separate step that clears the badge. Be deliberate about that one: it is private account state and fully reversible, but it also clears the notification badge in the Bluesky app for whoever else uses that account, so a workflow that acknowledges notifications is taking that decision on their behalf.
From AI assistants over MCP
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. Bluesky ships no first-party MCP server; community-maintained ones exist and are a reasonable choice if you want an assistant talking to your account from your own machine. What running Bluesky here adds is that the same nodes are canvas steps, so the workflow an agent helps you design then runs on a schedule with nobody present, chains with every other connector in one automation, and holds the app password once in a shared workspace rather than in each person's local config. Given that this connector publishes under your name to a public network, the sensible split is to hand an assistant the 29 read nodes and keep the 13 destructive ones behind conditions or approval steps. An agent reading Bluesky: Search Posts and Bluesky: List Notifications to build a digest is low risk; an agent holding Bluesky: Create Post and Bluesky: Follow Account is not.
What this integration deliberately does not cover
Naming the gaps is cheaper than having you find them. Direct messages are not built: they live on a different host from everything else here and Bluesky gates them behind a privileged app password, so building them would mean asking every user for access the rest of the integration does not use, to read private correspondence. The Ozone moderation endpoints are not built: they act on other people's accounts and content and authorize against a moderation service an ordinary account does not have, so effectively every node would fail for effectively every user. Account lifecycle is out, meaning account creation and deletion, email changes and handle changes, because provisioning and destroying accounts is administration rather than automation. App-password management is out, because a connector that can mint and revoke the credential class it authenticates with is a bad shape with no workflow benefit; you create the app password yourself, once, in the Bluesky settings. The unspecced namespace is out because the vendor's own naming says it changes without notice. Starter packs, push registration and preference writes are out as thin or client-specific surfaces. And the firehose is out because it is a websocket stream. Where an endpoint is simply not typed as its own node, the repository nodes above usually reach it anyway.
Troubleshooting
Test Connection fails and says the credential was rejected
The connection test mentions two-factor or an authentication factor token
Test Connection passes but every node returns somebody else's data
Test Connection passes but a read node still fails
Requests start failing partway through a run
An unfollow, unlike, unrepost or unblock node fails with an invalid AT-URI
A reply was published but nobody can see it in the thread
A list feed returns nothing at all
A record update wiped fields nobody touched
An account picker stays empty until you type
Related
The Bluesky MCP
What connecting Bluesky unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
Bluesky is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.