Menu

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.

Sign in to Bluesky as the account the workflows should act as, and open Settings.
Go to Privacy and security, then App passwords, and add one. Give it a name that will still make sense to somebody else later, such as the workspace or the workflow it is for.
Bluesky shows the app password once, at creation, and states that you will not be able to view it again. Copy it before you close the dialog. If you lose it, delete that one and generate another rather than hunting for it.
Leave the option to allow access to your direct messages switched off. That option is what Bluesky calls a privileged app password, and this integration does not read or send direct messages, so enabling it would grant access nothing here uses.
Note the identifier that goes with it. That is the account's handle, written without the leading at sign, or its DID. Both work everywhere in this integration.
Self-hosted accounts need one extra value: the service host of your own PDS. The service field is prefilled with https://bsky.social, so an ordinary account needs no change here. Plain http hosts are refused outright rather than accepted and downgraded.

Connect Bluesky to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Bluesky from the list, then click Create new credential.
Fill in Handle or DID with the account's handle, written without the leading at sign, or its DID, and paste the app password into App Password. A leading at sign is stripped for you if you paste one.
Leave Service URL as https://bsky.social unless the account is on a self-hosted PDS, in which case put your own host there.
The app password is stored encrypted and never appears in workflow logs. So are the session tokens Mattering derives from it. Revoking the app password in the Bluesky settings ends access here within about fifteen minutes, because the cached session is capped at that regardless of how long the token claims to live.
Click Test Connection. Mattering exchanges the identifier and app password for a session and then reads that session back, so a success names the handle and DID you are actually connected as.
Read the handle and DID the test reports rather than only the green result. A valid credential for the wrong account fails invisibly: every node returns somebody else's perfectly good data, and nothing looks broken until a post lands in the wrong place.
All 48 Bluesky nodes appear in your canvas palette.

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
Three causes, in the order worth checking. First, the value itself: this integration wants an app password created in the Bluesky settings, and it is easy to truncate a value you only get to see once, so generate a fresh one and paste it whole. Never substitute the account password here, whatever Bluesky's login endpoint would accept: an app password is the credential you can delete later without touching the account. Second, deletion: an app password removed in the Bluesky settings stops working, and because the session cache here is capped at fifteen minutes, a deletion you made a while ago will already have taken effect. Third, the identifier: it is the handle without the leading at sign, such as alice.example.com, or the DID. Try Test Connection again after correcting each one.
The connection test mentions two-factor or an authentication factor token
The account has email-based two-factor confirmation switched on, and an app-password login cannot complete it unattended because there is no human to read the emailed code. This is not a fault in the credential. Either turn that setting off for the account the automation uses, or move the connection to an account that does not require it. A dedicated automation account is the usual answer, and it is a better idea than weakening the security settings on somebody's personal login.
Test Connection passes but every node returns somebody else's data
The credential is valid for the wrong account. This is the failure mode the connection test is built to catch, which is why a successful test names the handle and DID it connected as rather than only reporting success. Read that line: if it is not the account you meant, the app password belongs to a different login. Nothing here is broken and nothing will look broken, because every node returns perfectly good data belonging to somebody else. Replace the credential with an app password from the correct account and re-run Bluesky: Get Session to confirm.
Test Connection passes but a read node still fails
Expected, and the reason is structural rather than a bug. Every node in this integration authenticates at the session exchange, so the connection test proves the app password and the service host and nothing else. Two things it cannot prove. Reads of another account's content can still fail on that account's blocks and moderation state, which no credential check can anticipate. And a custom feed is a third-party service: an offline generator answers with an unknown-feed error rather than an empty list, which is why Bluesky: Get Feed Details reports isOnline and isValid and is worth running before a scheduled workflow depends on somebody else's feed. Run Bluesky: Get Timeline as the real smoke test, since it needs nothing but the session.
Requests start failing partway through a run
Two different budgets can produce this and they need different fixes. Content writes are counted against a per-account budget in points, where creating a record costs more than deleting one, so a workflow that likes or follows once per row can exhaust it while a read-heavy workflow never notices. The fix is shape rather than pacing alone: batch reads with Bluesky: Get Posts, Bluesky: Get Profiles and Bluesky: Get Relationships instead of looping per row, and put a deliberate limit on anything that writes per item. The other budget is the login endpoint, which Bluesky limits per account; this integration is built to avoid it by refreshing an existing session rather than logging in again, so seeing that particular limit usually means many separate credentials or processes are logging in as the same account. Read Bluesky's own rate-limits page for the current numbers rather than any figure quoted elsewhere, because the vendor says its limits are likely to change.
An unfollow, unlike, unrepost or unblock node fails with an invalid AT-URI
Almost always the wrong URI was supplied. These four nodes delete a record you own, so they want 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. Passing the post's URI to Bluesky: Remove Like is the classic version of this. The correct value arrives as viewer state on any hydrated read: viewer.like and viewer.repost on a post from Bluesky: Get Posts or Bluesky: Get Timeline, and viewer.following and viewer.blocking on a profile from Bluesky: Get Profile. A blank viewer.following simply means you do not follow that account, so there is nothing to delete. A complete AT-URI has three parts after the scheme: a repository, a collection and a record key.
A reply was published but nobody can see it in the thread
The reply carried the wrong thread root. This is not an error and nothing failed: the post exists in your repository, it is just detached from the conversation, so it does not appear in context for anyone reading the thread. Bluesky: Create Post avoids this by resolving the root itself when you give it the post being replied to, with one extra read, so the fix is to supply the post you are replying to rather than assembling the reply reference by hand. If you are building the reference yourself, the root is the first post in the thread and the parent is the post you are answering, and they are only the same value when you are replying to a top-level post.
A list feed returns nothing at all
The list is almost certainly a moderation list rather than a curation list, and moderation lists have no feed. Run Bluesky: List Lists and check the purpose on the list you picked: a moderation list and a curation list can carry identical names, which is why the list picker shows purpose alongside the name. Point Bluesky: Get List Feed at a curation list instead. If the purpose is right and the feed is still empty, check the membership with Bluesky: Get List Members, since a list with no members produces an empty feed exactly like a wrong one does.
A record update wiped fields nobody touched
Bluesky: Create Or Update Record replaces a record whole and does not merge, so any field omitted from the object you send is deleted. This is how a profile update built field by field removes an avatar or a description. There is no version history and no undo. The safe pattern is to read the current record with Bluesky: Get Record, change only what you meant to change in the value it returned, put the whole object back, and pass the content hash you read as swapRecord so a concurrent edit fails loudly rather than being silently overwritten. If it has already happened, the record can only be rebuilt by writing the correct value again.
An account picker stays empty until you type
That is the intended behaviour rather than a broken picker, and it is the only shape this API can support. Bluesky publishes no endpoint that enumerates accounts, and there are tens of millions of them, so the account pickers in this integration are search-backed: they call Bluesky: Search Accounts as you type and show matching accounts by handle. Type part of a name or handle and results appear. Note what gets saved: the value stored is the account's DID rather than its handle, deliberately, because a handle is a rented DNS name whose owner can change it while a DID never changes, and every endpoint accepts either. Some fields are free text by design rather than empty pickers, including custom feed URIs, because no endpoint lists the feeds available to you, and post URIs, which normally arrive templated from the upstream node that found the post.

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.

Start Free Explore our Products