A Bluesky MCP that never asks for your account password
48 nodes on the AT Protocol: read timelines, author feeds, threads, search, custom feeds, lists, profiles, the follower graph and notifications, publish posts, likes, reposts, follows and blocks, and reach every other record type through a generic repository surface. 29 nodes read and 19 act. The credential is an app password you create in the Bluesky settings and can revoke at any time.
What the Bluesky MCP connector does
The Bluesky connector for Mattering Automations is 48 nodes on the AT Protocol XRPC API, the same interface the Bluesky app itself is built on. Timelines, author feeds, post threads, post hydration and network search cover reading. Custom feeds, lists and list feeds cover curation. Profiles, account search, followers, following, relationships, blocks and mutes cover the social graph. Notifications cover inbound activity. Ten publish and undo nodes cover posts, likes, reposts, follows and blocks. Four mute nodes cover the one genuinely private write surface. Seven generic repository nodes reach every record type the catalog does not name individually.
Every capability is a node on the Automations canvas, and every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. So an agent can run Bluesky: Search Posts for every mention of a brand this week, read the quote posts behind the loudest ones, draft replies, and stop there while a person decides whether anything gets published.
There is no Bluesky API key, and that shapes the whole connector. What you hold is an identifier, which is your handle or your DID, and an app password, which is a separate revocable credential you create in the Bluesky settings. An app password is not the account password: Bluesky describes it as a way to sign in to other Bluesky clients without giving full access to your account or password, it is shown once at creation, and you can delete it later without disturbing your own login. Those two values buy a session, and the session token is what every request actually carries. Mattering performs that exchange, caches the result and replaces it when it goes stale, so no node asks you to think about tokens.
The renewal path is deliberate rather than incidental. Bluesky rate limits the login endpoint per account, so a connector that logged in on every cold start would spend an account's daily login budget on nothing. This one refreshes an existing session first and only falls back to a full login when the refresh token is dead too. The cached session is also capped at fifteen minutes regardless of how long the token claims to live, which matters for a reason you can act on: an app password you revoke in the Bluesky settings stops working here inside about a quarter of an hour rather than whenever a process happens to restart.
Bluesky is a public federated network and the connector's honesty about writes follows from that. A record you create is public the instant it is written and is copied within seconds by the AppView, by relays and by independent mirrors. Deleting it removes it from your repository and asks the network to drop it, but it cannot un-fetch copies already taken and it cannot recall the notification the write already sent. Thirteen nodes are classed destructive for that reason, including Bluesky: Like Post and Bluesky: Follow Account, which have an undo button and still write a public record and fire a notification the undo does not recall. Bluesky runs no sandbox and this connector does no scheduling, so a post published from a node is a real post, seen by real people, the moment the step runs.
What is not here is worth reading before you plan anything. Direct messages are not built: they live on a different host and Bluesky gates them behind a privileged app password, which this connector deliberately does not ask you to create. Moderation is not built: the Ozone endpoints act on other people's accounts and authorize against a moderation service an ordinary account does not have, so every node would fail for almost everyone. Account creation, account deletion, handle changes and app-password management are all out on purpose, because a connector that can mint or revoke the credential class it authenticates with is a bad shape with no workflow upside. The firehose is out too, because it is a websocket stream rather than an HTTP endpoint.
There are also no trigger nodes, so Bluesky workflows here run on a schedule and poll rather than listening for a push. That is a real constraint and it has a cheap pattern: Bluesky: Get Unread Notification Count returns a single integer, so a schedule can check it every few minutes and only read the full notification list when it is above zero.
The seven repository nodes are what make 48 nodes cover an API with far more than 48 endpoints. Every object in Bluesky is a record in somebody's repository, so Bluesky: List Records, Bluesky: Get Record, Bluesky: Create Record, Bluesky: Create Or Update Record and Bluesky: Delete Record reach list definitions, list members, threadgates, postgates, starter packs and feed generators without a node each. Bluesky: Describe Repository reports which collections a repository actually holds, and it is what populates the collection pickers on the record nodes.
One connection, three surfaces
- Visual automations. Drag Bluesky nodes onto the canvas and wire them to triggers, conditions, and other apps.
- AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
- The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.
Every Bluesky node, ready to drop on the canvas
48 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 29
Bluesky: Describe Repository
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Resume notifications from a conversation that was muted. Private and fully reversible.
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.
Connecting Bluesky takes one credential
Bluesky issues no API keys at all, so there is nothing to provision, no application to register and no review to wait for. You create an app password in the Bluesky app under Settings, Privacy and security, App passwords, and paste the value it shows you once. Bluesky describes app passwords 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. Never give this connector the real account password. The creation dialog also offers an option to allow access to your direct messages, which is what Bluesky calls a privileged app password. Leave it off: this connector does not read or send direct messages and does not need that access. The service URL field exists for self-hosted accounts: it is prefilled with the Bluesky host, so change it only if the account lives on your own PDS. Plain http is refused, because an app password sent in the clear is interceptable.
Decide which Bluesky account the workflows should act as. Every node runs as that account, its posts are attributed to it and its likes and follows are public, so a dedicated account is usually a better idea than an individual's personal one.
In the Bluesky app, open Settings, then Privacy and security, then App passwords, and add one. Copy the value it shows: Bluesky states you will not be able to view it again. Leave the option to allow access to your direct messages switched off, because this connector does not read or send direct messages and does not need that access.
If the account is on a self-hosted PDS rather than bsky.social, have the service host ready. Ordinary Bluesky accounts need nothing here.
In Mattering Automations, open Connectors, click Add Connector and choose Bluesky. Create a new credential, fill in Handle or DID with your handle written without the leading at sign, and paste the value into App Password. The Service URL field is prefilled with the Bluesky host, so change it only if the account is self-hosted.
Click Test Connection. Mattering exchanges the app password for a session and then reads it back, so the result names the handle and DID you are actually connected as. That last part is the check worth having: a valid credential for the wrong account fails invisibly, because every node then returns somebody else's perfectly good data.
All 48 Bluesky nodes appear in the canvas palette. Run Bluesky: Get Session first, then Bluesky: Get Timeline, because the connection test proves the credential and not any individual node. The app password is stored encrypted and never appears in workflow logs, and revoking it in the Bluesky settings ends access here within about fifteen minutes.
Common uses for the Bluesky MCP
Brand and mention monitoring that reads the whole conversation
Bluesky: Search Posts is the node this starts from: a term, optionally narrowed to a language, a linked domain, hashtags, an author or a date range, with a mentions filter that catches every post naming an account even when it does not name the brand. Bluesky: Get Post Thread then pulls the replies under anything worth reading, and the pairing that most monitors miss is Bluesky: Get Post Reposters with Bluesky: Get Post Quotes, because a quote post carries the commentary a repost does not and is usually the half a sentiment check should actually read. One caution belongs in the design rather than in a surprise: Bluesky documents that the search cursor may not walk the entire result set, so treat deep pagination as best effort rather than as a complete export.
Publishing that a person signs off before it is public
Bluesky: Create Post publishes, and on this network publishing is the irreversible step. The workable shape is to generate the text elsewhere, park it for review in a Mattering Productivity task or a Comms message, and only run the post node after somebody approves it. For an image, Bluesky: Upload Blob comes first and is safe on its own: an uploaded blob that is never referenced by a record is visible to nobody and is garbage collected, which is why it is the one write in the publishing path that is not classed destructive. Two mechanical facts save a rewrite later. The text limit is 300 graphemes rather than characters, so emoji and many scripts cost one grapheme each. And links and mentions in post text are not detected automatically: a URL typed into the text renders as unlinked plain text unless a facet covers it.
Watching a set of accounts with one call instead of one call each
Bluesky: Get List Feed reads the combined posts of everyone on a curation list, newest first, which replaces a loop of author-feed calls and lets somebody edit the watchlist in the Bluesky app without touching the workflow. Bluesky: List Lists finds the lists an account has created and Bluesky: Get List Members reads who is on one. The trap to design around is list purpose: a moderation list and a curation list can carry identical names, and pointing a list feed at a moderation list returns nothing, because moderation lists have no feed. For a single account instead of a set, Bluesky: Get Author Feed does the same job with a filter that decides whether replies, media posts or self-threads are included.
Follower and relationship intelligence without paging the whole graph
Bluesky: Get Relationships answers, for up to 30 accounts at once, whether you follow them and whether they follow you back, which is far cheaper than walking a follower list to ask whether you already follow somebody. Bluesky: Get Followers and Bluesky: Get Following read the graph itself when you do need the list, and Bluesky: Get Profiles enriches up to 25 accounts in one call rather than one request each. Bluesky: Resolve Handle To DID is worth running once on anything you intend to store: a handle is a rented DNS name whose owner can change it, so a workflow keyed on a handle can silently start watching nobody, while a DID never changes.
Notification triage that a schedule can afford to run often
Bluesky: Get Unread Notification Count returns a single integer, so a scheduled workflow can poll it cheaply and only call Bluesky: List Notifications when there is something to read. Each notification names who acted, what they did and the record they created, which is enough to route a reply to one place and a new follower to another. Two behaviours matter here. Reading notifications does not mark anything read, which is what makes a poll then acknowledge pattern possible at all. And Bluesky: Mark Notifications Seen is what clears the badge, so a workflow that acknowledges notifications is taking that decision on behalf of whoever else uses the account.
Auditing and cleaning up your own history
Bluesky: List Records walks the raw records in one collection of your own repository: your posts, your likes, your follows, your list definitions. It returns stored records rather than hydrated views, so a like record is a subject and a timestamp with no profile or post text attached, and Bluesky: Get Posts or Bluesky: Get Profiles is what turns those into something readable. The four undo nodes take the AT-URI of your own record rather than of the post, which is the single most common mistake here: Bluesky: Remove Like wants the URI at viewer.like on a hydrated post, and Bluesky: Unfollow Account wants the one at viewer.following on a profile. Bluesky: Unblock Account is worth reading before you automate it, because a block suppresses visibility and interaction without changing the follow graph, which is why Bluesky notes that a rapid block then unblock does not work as a way to remove a follower.
Example: A morning mention digest with replies drafted but not sent
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a daily schedule fires. This connector has no trigger nodes, so Bluesky workflows poll on a schedule rather than listening for a push.
Bluesky: Search Posts runs the brand terms with a since value covering the last day, sorted newest first, so the result is the day's conversation rather than an all-time ranking.
Bluesky: Get Post Quotes and Bluesky: Get Post Reposters run against the posts with the most engagement, because a quote carries commentary a repost does not and the two together are what amplification actually looked like.
Bluesky: Get Profiles enriches the accounts behind the loudest posts in one call, so the digest can say who these people are rather than listing handles.
An AI step groups the mentions by theme, flags anything that reads as a complaint, and drafts a short reply for each one. Nothing has been written to Bluesky at this point.
A task is created in Mattering Productivity with the digest and the drafts, so a person reads them before the network does.
On approval, Bluesky: Create Post publishes the agreed reply, with the post being replied to supplied so the connector resolves the thread root itself. That step is deliberately last and deliberately behind a human, because a reply with the wrong root detaches from its thread and a published post cannot be un-published.
Bluesky MCP questions, answered
What can this connector actually do in Bluesky?
48 nodes: 29 read and 19 act. Reads cover the home timeline, an account's author feed, post threads, hydrating posts by URI, network post search, likes, reposters and quotes on a post, custom feeds and their online status, feeds an account authored, list feeds, list members, profiles singly and in batches, account search, followers, following, relationships, blocked accounts, muted accounts, notifications and the unread count, the session itself, handle resolution, and the raw repository surface. Writes cover creating and deleting posts, liking and un-liking, reposting and removing a repost, following and unfollowing, blocking and unblocking, muting and unmuting accounts and threads, marking notifications seen, uploading a blob, and creating, replacing and deleting arbitrary records. Not included and worth knowing before you plan: direct messages, which live on a different host behind a privileged app password; the Ozone moderation endpoints, which authorize against a moderation service an ordinary account does not have; account creation, deletion and handle changes; app-password management; the firehose, which is a websocket stream rather than an HTTP endpoint; and starter packs. There are also no trigger nodes, so workflows poll on a schedule.
Does this work with Claude, ChatGPT, or other AI assistants?
Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and work with Bluesky through them. Matter, the assistant built into the platform, uses the same nodes natively. The same nodes are also steps on the automation canvas, so the workflow an agent helps you design can then run on a schedule with nobody present. Given that this connector publishes to a public network under your name, the sensible split is to hand an assistant the 29 read nodes and keep publishing, following and blocking behind a condition or an approval step.
Do I have to give Mattering my Bluesky password?
No. Bluesky issues no API keys, so what you store is your identifier, which is your handle or your DID, plus an app password you create under Settings, Privacy and security, App passwords. Bluesky describes app passwords as the way to sign in to other Bluesky clients without giving full access to your account or password, and warns that the value is shown once because you will not be able to view it again. You can delete an app password later without disturbing your own login. Two further points. The creation dialog offers an option to allow access to your direct messages, which Bluesky treats as a privileged app password; this connector does not build direct messages, so leave it off. And the cached session here is capped at fifteen minutes, so an app password you delete stops working within about a quarter of an hour rather than at some unpredictable later point.
Does Bluesky publish its own MCP server?
Bluesky ships no first-party MCP server. Several community-maintained Bluesky MCP servers exist and are worth knowing about if you want an assistant talking to your account from your own machine; none of them is from Bluesky, and none is on Bluesky's own documentation. What this connector adds over that shape is not a longer tool list. The nodes run on a schedule or inside a larger workflow with nobody present, they chain with every other connector in one automation, the app password is held once in a shared workspace rather than in each person's local config, and the 13 nodes that publish or delete carry destructive flags so an agent cannot reach them by accident.
What are Bluesky's rate limits, and why does the connector refresh instead of logging in again?
Bluesky publishes its limits, and one number drives the connector's design. The login endpoint, createSession, is limited per account rather than per IP, which means a fleet of short-lived workers logging in on every cold start would burn an account's login budget and lock the connector out for everyone using it. Bluesky's own bot guidance 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 this connector caches the session, renews it with the refresh token first, and only performs a full login when the refresh token is dead too. Separately there is a per-account budget on content writes, counted in points with a create costing more than a delete, which is why the nodes that write in a loop say so in their own descriptions and why a job that likes or follows per row should pace itself. Bluesky states that all of the limits it describes are likely to evolve over time, so read the vendor's rate-limits page rather than treating any number here as fixed. A request that crosses a limit usually receives an HTTP 429, which is Bluesky's own wording rather than a guarantee.
Can an agent post to Bluesky on its own, and what happens if it gets it wrong?
It can, and this is the part to be deliberate about, because Bluesky runs no sandbox and this connector publishes the moment the step runs. A post is public as soon as it is written and is copied within seconds by the AppView, by relays and by independent mirrors. Deleting it removes it from your repository and asks the network to drop it, which stops Bluesky serving it, but it cannot un-fetch copies already taken and it cannot recall the notification a reply or a mention already sent. That is why 13 nodes are classed destructive, including likes and follows, which technically have an undo and still write a public record and notify somebody. It is also a rules point rather than only a technical one: Bluesky's developer guidelines prohibit generating automated or bulk interactions, including any that would cause a notification to a user such as a follow, a like or a reply, so a connector that makes mass following easy is a connector that can get an account actioned. Put publishing, following and blocking behind an approval step.
Is there a sandbox or a test environment for Bluesky?
No. Bluesky ran a federation sandbox once and shut it down in 2024, and there is no staging environment or test mode in its place, so anything a node writes is a real record on a public network seen by real people. The Bluesky app does have private drafts, but they are a feature of the client rather than something this connector can write to: Bluesky: Create Post publishes. The practical answer is a throwaway account: create one, follow nobody, put its app password on a separate credential and let anything that writes run there until you trust it. The reads are safe to exercise on a live account, and Bluesky: Get Session plus Bluesky: Get Timeline is the honest smoke test, because the connection test proves the credential rather than any individual node.
Does this need a paid plan, and does it work with a self-hosted PDS?
No node in this connector is gated behind a paid Bluesky plan or a developer tier: Bluesky's API needs no key provisioning, no application registration and no review, and creating an app password is a settings screen rather than a plan feature. Self-hosted accounts work unchanged, which is the point of AT Protocol being a protocol: set the optional service URL on the credential to your own PDS host and the same 48 nodes work against it. One host serves both namespaces either way, because an authenticated request for app.bsky data is proxied by your PDS to the AppView. The connector deliberately reads through your session rather than through the public unauthenticated read host, because reading with a session is what makes viewer state appear in responses, and those fields are exactly where the undo nodes get the record URIs they need.
Put Bluesky to work inside your workspace
Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.
All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Bluesky is a product of its respective owner; Mattering is an independent platform.