A Backblaze B2 MCP for buckets, versions and the things that quietly cost money
Connect an application key id and application key, and 31 nodes land on the canvas: list and create buckets, upload from a URL, copy, hide and delete versions, download small files, run multipart uploads, mint scoped application keys and time-limited download links, set Object Lock, and manage event notification rules. Every native B2 endpoint, with the versioning traps written on the nodes.
What the Backblaze B2 MCP connector does
The Backblaze B2 connector for Mattering Automations is 31 nodes on the B2 Native API v4, covering all 31 native endpoints: buckets, account information, file listing by name and by version, file writes including upload, copy, hide and delete version, downloads and time-limited share links, the whole large file family, application key management, Object Lock legal holds and retention, and the two event notification rule endpoints. Worth noting because the vendor's own operations index disagrees: that page lists 29 and omits the two notification rule endpoints, which have live reference pages and appear in Backblaze's own transaction class list.
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can find what a bucket is actually costing with Backblaze B2: List File Versions, mint a time-limited download link for a colleague with Backblaze B2: Get Download Authorization, or upload a generated report straight from a URL, without anyone opening the B2 console.
The version is v4 deliberately. Backblaze's endpoint reference documents v4 on every page, and the older prose guide that a search commonly lands on still shows v3 in its examples, which is the trap: a parser written against the v3 shape reads a flat apiUrl that v4 does not have and sends every later request to nowhere. Both versions work today, Backblaze states it has no plans to drop old versions and would give at least a year's notice, and nothing is currently deprecated. This connector is v4 throughout.
The most important thing to understand about B2 is that a delete is not what an object-storage instinct expects. B2 buckets are versioned by default and versioning cannot be turned off, so every upload to an existing name creates a new version and the newest is what a download by name serves. Backblaze B2: Hide File is NOT a delete: it writes a hide marker version, after which the name returns 404 and disappears from the file name listing, while every earlier version still exists, is still reachable by id, and is STILL BILLED. Hiding reclaims no storage. Backblaze B2: Delete File Version IS a delete, of ONE version, and if older versions exist the next most recent silently becomes the one served by name, so a delete can look like it did nothing. Removing a file completely means running it over every version. The S3-shaped instinct to delete an object by name maps to hiding, not to deleting, and getting that backwards either leaves an unbounded bill or destroys data.
The safety modeling follows from that. Of the 31 nodes, 13 read and 18 act, and four are flagged destructive: Backblaze B2: Delete File Version, Backblaze B2: Delete Bucket, Backblaze B2: Cancel Large File and Backblaze B2: Delete Application Key. The bucket delete refuses unless the bucket holds no version of any file, including hide markers and unfinished large files, so it fails rather than destroying something you forgot about; what it does lose for good is the bucket's configuration and its globally unique name. Cancelling a large file discards every part already uploaded to it and nothing else, since an unfinished large file was never visible in the bucket. Deleting an application key touches no data at all and cannot be undone, because the secret half was shown exactly once at creation.
One connection, three surfaces
- Visual automations. Drag Backblaze B2 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 Backblaze B2 node, ready to drop on the canvas
31 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 13
Backblaze B2: Download File By ID
Download one specific file VERSION by its id. This is how you read a version that is no longer current, including one hidden behind a hide marker, which download by name cannot reach. Same body handling as download by name: UTF-8 text as content, anything else base64, capped at 256 KB with truncated and the real size always reported.
Backblaze B2: Download File By Name
Download the CURRENT version of a file by bucket name and file name. Text that decodes as UTF-8 comes back as content with encoding utf-8; anything else comes back base64 in the same field with encoding base64. The body is capped at 256 KB of raw bytes, and truncated plus the real size are always reported, so a clipped read is never mistaken for a whole one. For anything larger, use Backblaze B2: Get Download Authorization and hand the URL to a worker that can stream it. A hidden name answers 404 even though its earlier versions still exist; fetch those by id instead. This node goes to the account's download host, which is a different host from every other node here.
Backblaze B2: Get Account Info
Report what this connection's application key actually is: the account id, the cluster's API, download and S3 host names, the recommended and minimum part sizes for large file uploads, and the key's own capability list, bucket restrictions and name prefix. Run it FIRST when a node returns unauthorized, because the usual cause is a key missing a capability or restricted to a different bucket rather than a broken credential. This node makes no API call of its own beyond the authorization every node already performs, and it NEVER returns the authorization token.
Backblaze B2: Get Bucket Notification Rules
Read a bucket's event notification rules: which events fire a webhook, the name prefix each rule watches, the target URL and custom headers, and whether a rule has been SUSPENDED by Backblaze along with the reason. Note that this endpoint answers with a top level JSON ARRAY rather than an object, so downstream paths read data[].eventNotificationRules[]. Read this before writing rules, because setting them replaces the whole list.
Backblaze B2: Get File Info
Fetch one file VERSION's metadata without downloading it: name, size, content type, SHA1, custom file info, Object Lock retention and legal hold, encryption and upload time. The cheap way to confirm a version exists, and the documented way to check whether a Backblaze B2: Finish Large File call that timed out actually succeeded before retrying it.
Backblaze B2: Get Upload Part URL
Mint an upload URL and token for uploading PARTS of one large file. Classed a Safe Read because it creates nothing, but what it returns is a write credential for that large file, valid for at most 24 hours or until the endpoint rejects an upload. One token cannot serve two part uploads at the same time, so request one per parallel stream. For ordinary use, Backblaze B2: Upload Part fetches its own URL and retries on a fresh one, and this node is only needed to hand the upload to an external worker.
Backblaze B2: Get Upload URL
Mint an upload URL and upload token for a bucket. Classed a Safe Read because it creates, changes and deletes nothing, but WHAT IT RETURNS IS A WRITE CREDENTIAL: whoever holds the pair can upload into that bucket without any further authentication until it expires, which Backblaze documents as at most 24 hours or until the endpoint rejects an upload. Use this only to hand an upload off to a worker that can stream a large file; for ordinary uploads use Backblaze B2: Upload File, which fetches its own URL and retries on a fresh one. One token cannot serve two uploads at the same time, so request one per parallel stream.
Backblaze B2: List Application Keys
List the account's application keys with each one's name, capabilities, bucket restrictions, name prefix and expiration. The secret half of a key is NEVER returned here: it is shown exactly once, when the key is created. This node populates the key picker on Backblaze B2: Delete Application Key. Requires the listKeys capability, which most restricted keys do not have.
Backblaze B2: List Buckets
List the account's B2 buckets with each one's type, CORS and lifecycle rules, default encryption and Object Lock configuration. This is the node every bucket picker in this connector reads from, and the cheapest call for confirming the credential works end to end. Note that this is the one listing endpoint B2 documents as a POST. IF YOUR APPLICATION KEY IS RESTRICTED TO A BUCKET you must fill in bucketId or bucketName: asking for all buckets with a restricted key is unauthorized.
Backblaze B2: List File Names
List the CURRENT version of each file in a bucket, in name order. Hidden files are not listed and neither are older versions, so this is the view that matches what a download-by-name would serve. Use Backblaze B2: List File Versions instead when you need hide markers or history. This node populates the file name picker on the hide node. A prefix-restricted application key must pass a prefix at least as restrictive as its own or the listing is denied.
Backblaze B2: List File Versions
List EVERY version of every file in a bucket, ordered by name and then newest first within a name. This is the only view that shows history and hide markers: a version with action "hide" and contentType application/x-bz-hide-marker is a hide marker, not a file. It is also where the fileId for Backblaze B2: Delete File Version comes from. Every version listed here is BILLED STORAGE, so this is the node that finds what a bucket is actually costing. Backblaze warns that accumulating millions of versions of one name degrades listing and deletion, raises 503 rates, and can eventually block the account from uploading.
Backblaze B2: List Parts
List the parts already uploaded for one unfinished large file, with each part's number, size and SHA1. This is how you rebuild the partSha1Array that Backblaze B2: Finish Large File needs after a workflow was interrupted, and how you find which part number to resume from. Note that B2 gates this endpoint on the writeFiles capability rather than listFiles, which is easy to miss when scoping a read only key.
Backblaze B2: List Unfinished Large Files
List large file uploads that were started and never finished. Their parts are stored and BILLED even though no file is visible in the bucket, so this is the node that finds silent storage cost. Clear them with Backblaze B2: Cancel Large File, or automatically with a lifecycle rule using daysFromStartingToCancelingUnfinishedLargeFiles.
Action nodes 18
Backblaze B2: Cancel Large File
DESTRUCTIVE: cancel an unfinished large file and discard EVERY PART already uploaded to it. Those bytes are gone and cannot be recovered, and the upload has to start again from Backblaze B2: Start Large File. What is NOT affected is the bucket's existing contents: an unfinished large file was never a visible file, so no version of anything is lost and nothing that was previously downloadable stops being downloadable. This is the right node for clearing the billable parts that Backblaze B2: List Unfinished Large Files reports.
Backblaze B2: Copy File
Copy a file version inside B2 without moving the bytes through this automation. The destination may be a different bucket in the same account; leave destinationBucketId blank to copy within the source's own bucket. The source is left untouched, so a move is this node followed by Backblaze B2: Hide File or Delete File Version. Copying onto an existing name creates a NEW VERSION of that name rather than replacing it. Files larger than 5 GB must be copied with Backblaze B2: Copy Part instead.
Backblaze B2: Copy Part
Copy a byte range of an existing file straight into a part of a large file, without the bytes passing through this automation. This is how a file above 5 GB is copied, and how a new file is assembled from pieces of existing ones. Same numbering rules as Backblaze B2: Upload Part: 1 to 10000, contiguous, starting at 1.
Backblaze B2: Create Application Key
Create an application key scoped to a capability list, optionally restricted to specific buckets and a name prefix. THE SECRET IS RETURNED ONCE, in this response's applicationKey field, and can never be retrieved again, so capture it in the same run or the key is useless. Grant the narrowest capability set that works: a key holding writeKeys can mint any other key and is therefore equivalent to full account access. Reversible with Backblaze B2: Delete Application Key. Requires the writeKeys capability.
Backblaze B2: Create Bucket
Create a B2 bucket. Bucket names are GLOBALLY unique across all of Backblaze, not just your account, so a create fails if the name is taken anywhere. Reversible with Backblaze B2: Delete Bucket while the bucket still holds no version of any file. Setting bucketType to allPublic makes every file in it readable by anyone with the URL and no authentication. Turning fileLockEnabled on cannot be undone.
Backblaze B2: Delete Application Key
DESTRUCTIVE: permanently revoke an application key. Every integration authenticating with it starts failing immediately, and the key CANNOT be restored: its secret half was shown only once at creation, so recreating it means issuing a new key and updating everything that used the old one. What is NOT affected is data: no bucket, file or version is touched. Check what the key is used for with Backblaze B2: List Application Keys first. Note that on API v4 this only works with a Multi-Bucket Application Key.
Backblaze B2: Delete Bucket
DESTRUCTIVE: delete a B2 bucket. The bucket must contain NO VERSION OF ANY FILE, including hide markers and unfinished large files, so the call fails rather than destroying data you forgot about. What IS lost and not recoverable is the bucket's configuration (CORS rules, lifecycle rules, notification rules, encryption and Object Lock settings) and its name, which is globally unique and may be taken by somebody else once released.
Backblaze B2: Delete File Version
DESTRUCTIVE: permanently delete ONE VERSION of a file. Backblaze describes this as deleting the version and all of its data as if it had never been uploaded, and nothing restores it. Read the scope carefully in both directions. It deletes only the version you name, so if older versions exist the next most recent SILENTLY becomes the one served by name and the delete can look like it did nothing; run it over every version from Backblaze B2: List File Versions to remove a file completely. If it was the only version, the file is gone entirely. Deleting a hide marker UNHIDES the name. Pointed at an unfinished large file this behaves like cancelling that upload. Use Backblaze B2: Hide File instead when you want a recoverable soft delete.
Backblaze B2: Finish Large File
Assemble the uploaded parts into a single file, which is the moment it becomes visible in the bucket. partSha1Array must list every part's SHA1 IN PART ORDER starting at part 1, and B2 rejects the call if the set is incomplete or the digests do not match. The finished file's contentSha1 comes back as the literal "none", which is normal for large files. ONE RETRY TRAP worth knowing: if this call times out after it actually succeeded, retrying returns HTTP 400, so check with Backblaze B2: Get File Info before assuming it failed.
Backblaze B2: Get Download Authorization
Mint a time limited token that lets anyone holding it download files under a name prefix in a private bucket, with no further authentication. Append it to a download URL as the Authorization header or as an ?Authorization= query parameter. THE TOKEN GRANTS REAL READ ACCESS to everything matching the prefix for its whole lifetime and CANNOT BE REVOKED EARLY, so keep validDurationInSeconds short, make the prefix as narrow as possible, and keep the value out of anywhere URLs get logged or forwarded casually. Nothing is created that needs cleaning up: the token expires on its own. Requires the shareFiles capability.
Backblaze B2: Hide File
Hide a file name so it stops being served. THIS IS NOT A DELETE, and the difference matters twice over. What it actually does is write a new VERSION that is a hide marker, after which the name returns 404 on download and disappears from Backblaze B2: List File Names. Every earlier version still exists, is still reachable by fileId, still appears in Backblaze B2: List File Versions, AND IS STILL BILLED, so hiding reclaims no storage. It is reversible two ways: upload a new version of the name, or delete the hide marker itself with Backblaze B2: Delete File Version, since the marker is a version with its own fileId. If you meant to free the storage, delete the versions instead.
Backblaze B2: Set Bucket Notification Rules
REPLACE a bucket's event notification rules with the list you supply. This is a whole-list write, not a merge: any rule you leave out is removed and its webhook stops firing immediately, so read the current set with Backblaze B2: Get Bucket Notification Rules first and write the edited list back. Passing an empty array removes every rule. The response, like the read, is a top level JSON array. Note that outbound notifications are the one part of this API that Backblaze bills as Class D transactions.
Backblaze B2: Start Large File
Begin a multipart upload and return the large file's id, which every later step needs. Nothing is visible in the bucket until Backblaze B2: Finish Large File succeeds, but the parts you upload ARE STORED AND BILLED from the moment they land, so an abandoned large file costs money indefinitely. Clean up with Backblaze B2: List Unfinished Large Files and Cancel Large File, or set a lifecycle rule with daysFromStartingToCancelingUnfinishedLargeFiles on the bucket. Reversible with Cancel Large File.
Backblaze B2: Update Bucket
Update a bucket's settings. Only the fields you fill in are sent, but each one you DO send REPLACES that setting wholesale rather than merging: sending corsRules or lifecycleRules drops any rule you left out, so read the current set with Backblaze B2: List Buckets first and write the edited list back. Set ifRevisionIs to the bucket's current revision to make the update fail rather than clobber a concurrent change. Switching bucketType to allPublic makes every file in the bucket world readable.
Backblaze B2: Update File Legal Hold
Turn an Object Lock legal hold on or off for one file version. While a hold is ON the version cannot be deleted or overwritten by anyone, including the account owner, and it has no expiry: it stays until someone turns it off. That is what makes this reversible in both directions and worth reaching for over a retention period when the end date is unknown. Requires Object Lock enabled on the bucket and the writeFileLegalHolds capability.
Backblaze B2: Update File Retention
Set or change an Object Lock retention on one file version. READ THE TWO MODES BEFORE USING THIS. GOVERNANCE retention blocks deletion until the timestamp passes, but a key holding the bypassGovernance capability can shorten or remove it, which is why this node is reversible. COMPLIANCE retention CANNOT BE SHORTENED OR REMOVED BY ANYONE, including the account owner and Backblaze support, until it expires, so a compliance retention set far in the future makes that version undeletable and its storage unavoidably billable for the whole period. Requires Object Lock enabled on the bucket and the writeFileRetentions capability.
Backblaze B2: Upload File
Upload a file. This node does BOTH halves of B2's upload flow: it fetches a fresh upload URL for the bucket, uploads the bytes with the SHA1 checksum B2 requires, and on a 401, 408, 429 or 5xx it fetches a NEW upload URL and retries once, which is Backblaze's own documented advice. Give it content_url and the runner downloads that URL and stores the bytes, which is the right shape for real files; give it content for small inline text. One or the other, never both. UPLOADING TO A NAME THAT ALREADY EXISTS DOES NOT REPLACE ANYTHING: B2 buckets are versioned and the old version stays, still stored and still billed, until something hides or deletes it. Files above the node's 100 MB cap should use the large file nodes.
Backblaze B2: Upload Part
Upload one part of a large file. Like Backblaze B2: Upload File, this node does both halves: it fetches a fresh part upload URL, uploads the bytes with their SHA1, and retries once on a new URL after a 401, 408, 429 or 5xx. Part numbers run from 1 to 10000 and MUST BE CONTIGUOUS STARTING AT 1, or Backblaze B2: Finish Large File rejects the set. Every part except the last must be at least the account's minimum part size, which Backblaze B2: Get Account Info reports as absoluteMinimumPartSize. Keep each part's SHA1 from this node's output: finishing the file needs all of them in order.
Connecting Backblaze B2 takes one credential
You supply two values from the Application Keys page of your Backblaze account: the application key id and the application key itself, whose secret half is shown once when the key is created and is never retrievable again. What happens next is worth understanding, because it explains a failure mode you will otherwise find puzzling. Those two values authenticate exactly one call, an authorization request sent as HTTP Basic to a fixed host, and that call returns two things every other request needs: an authorization token valid for at most 24 hours, and the API host for the CLUSTER your account lives on, which Backblaze assigns per account so it cannot be guessed or hardcoded. Mattering performs that exchange for you and caches the result, refreshing well inside the token's lifetime so a key revoked in the Backblaze console stops working quickly rather than a day later, and it retries once on an expired token by re-authorizing and replaying the request, which is Backblaze's own documented advice. Node access is gated by the key's CAPABILITIES rather than by a plan, and that is the gating to check before you build. A key restricted to one bucket cannot list all buckets at all: on v2 and later, asking for every bucket with a restricted key is unauthorized, so fill in the bucket filter. Listing parts is gated on writeFiles rather than listFiles, which is easy to miss when scoping a read-only key. Listing keys needs listKeys and creating them needs writeKeys, which is effectively full account access since a key that can mint keys can mint any key. Download authorizations need shareFiles, and the Object Lock nodes need Object Lock enabled on the bucket plus the matching write capability. On v4, deleting an application key works only with a Multi-Bucket Application Key. Cost is unusual enough to state: Backblaze's pricing page states that Class A, B and C transactions are free for pay-as-you-go customers, and every native endpoint this connector calls is Class A, B or C. Class D covers outbound event notification deliveries rather than API calls.
In your Backblaze account, open the Application Keys page and create a key. Give it the narrowest capability set that covers the nodes you intend to run, and restrict it to a bucket and a name prefix if that fits the job.
Copy both halves immediately. The application key id stays visible, but the application key itself is shown once at creation and cannot be retrieved afterwards.
In Mattering Automations, open Connectors, click Add Connector, choose Backblaze B2, and create a credential with the two values.
Click Test Connection. Mattering runs the authorization exchange and reports what came back: the cluster host your account lives on and the key's own capability list, bucket restrictions and name prefix. That is more useful than a bare tick, because when a node later returns unauthorized the usual cause is a missing capability rather than a broken key.
All 31 Backblaze B2 nodes appear in the canvas palette. Run Backblaze B2: List Buckets first. If the key is restricted to one bucket, fill in the bucket id or name, because an unfiltered listing with a restricted key is refused.
Common uses for the Backblaze B2 MCP
Archive generated files without holding the bytes
Backblaze B2: Upload File takes a content URL and the runner downloads it and stores it, which is the right shape for real files: a report a worker produced, an export from another connector, an attachment from a webhook. The node does both halves of B2's upload flow itself, fetching a fresh upload URL and retrying once on a new one if the first is rejected, which is Backblaze's own documented advice and something a static graph cannot express by hand. Know what an upload does to an existing name, because it is the difference between a tidy archive and a growing bill: it does not replace anything. B2 buckets are versioned, so the old version stays, stored and billed, until something hides or deletes it.
Find what a bucket is actually costing
Two nodes turn a surprising invoice into a report. Backblaze B2: List File Versions shows every version of every file, and every version listed there is billed storage, which is where the cost of a workflow that uploads the same report every hour actually lives. Backblaze B2: List Unfinished Large Files finds the other quiet one: parts uploaded to a multipart upload that never finished are stored and billed even though no file is visible in the bucket. A scheduled sweep can write both into a Mattering database, open a task when version counts climb, and clear stalled uploads with Backblaze B2: Cancel Large File.
Share a private file without making the bucket public
Backblaze B2: Get Download Authorization mints a time-limited token that lets whoever holds it download files under a name prefix in a private bucket, appended to a download URL as a header or a query parameter. Read the node's own warning as part of the design: the token grants real read access to everything matching the prefix for its whole lifetime and cannot be revoked early, so keep the duration short, make the prefix as narrow as the job allows, and keep the value out of anywhere URLs get logged or forwarded casually. Nothing needs cleaning up afterwards, because the token expires on its own.
Soft delete that is actually recoverable
Backblaze B2: Hide File is the node most people want when they think they want a delete. It writes a hide marker, the name stops being served and disappears from the file name listing, and every earlier version survives, still reachable by id and still listed by version. That makes it reversible two ways: upload a new version of the name, or delete the hide marker itself, since the marker is a version with its own id. The trade is explicit rather than hidden: hiding reclaims no storage and the old versions keep being billed, so a retention workflow eventually has to delete versions rather than only hiding names.
Scoped keys and expiring access, minted from a workflow
Backblaze B2: Create Application Key issues a key scoped to a capability list, optionally restricted to specific buckets and a name prefix, which is how a per-customer or per-service credential gets issued without a console visit. Two facts belong to that node rather than to a footnote: the secret is returned once in the response and can never be retrieved again, so capture it in the same run or the key is useless, and a key holding the capability to write keys can mint any other key, so treat that one as equivalent to full account access. Backblaze B2: List Application Keys is the audit half, and Backblaze B2: Delete Application Key revokes.
Retention rules with a compliance edge worth reading first
Backblaze B2: Update File Legal Hold and Backblaze B2: Update File Retention put Object Lock under workflow control, and the difference between the two modes matters more than the syntax. A legal hold is reversible in both directions and has no expiry, which makes it the better tool when the end date is unknown. Governance retention blocks deletion until its timestamp passes but can be shortened or removed by a key holding the bypass capability. Compliance retention cannot be shortened or removed by anyone, including the account owner, until it expires, so a compliance date set far in the future makes that version undeletable and its storage unavoidably billable for the whole period. Lifecycle rules on the bucket nodes are the other side of the same coin: they schedule irreversible deletion days later and quietly, and a wrong prefix expires the wrong files.
Example: Archive a nightly export and keep the version count under control
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a nightly schedule fires and an upstream step produces the export, leaving a URL the runner can fetch.
Backblaze B2: Upload File stores it, taking the content URL rather than inline bytes. Because B2 buckets are versioned and cannot be unversioned, this creates a new version of the name rather than replacing yesterday's, which is the behaviour the rest of the workflow is built around.
Backblaze B2: List File Versions reads back every version of that name, oldest last, so the workflow can see exactly how many copies are being billed.
A condition keeps the most recent versions the retention policy allows and passes the rest to Backblaze B2: Delete File Version, one call per version. This is the irreversible step: Backblaze describes it as deleting the version and all of its data as if it had never been uploaded, and note that deleting the current version silently promotes the next most recent to being served by name.
Backblaze B2: List Unfinished Large Files runs in the same pass and Backblaze B2: Cancel Large File clears anything stalled, because unfinished parts are stored and billed while being invisible in the bucket.
The version counts and bytes land in a Mattering database next to last night's, and a task opens for a person only if the count moved further than the policy should have allowed.
Backblaze B2 MCP questions, answered
What Backblaze B2 operations are supported?
31 nodes covering all 31 native API endpoints: 13 read and 18 act. Buckets (list, create, update, delete), account information, file listing (names, versions, get info), file writes (get upload URL, upload, copy, hide, delete version), downloads and sharing (by name, by id, get download authorization), large files (start, get part upload URL, upload part, copy part, finish, cancel, list unfinished, list parts), application keys (list, create, delete), Object Lock (legal hold, retention) and event notification rules (get, set). Deliberately not included: the S3-compatible API, which would be a second way to do what these nodes already do, with different delete semantics on the same buckets and a strictly smaller feature set on B2; and the Partner API, which is a separate suite with a separate audience.
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 use them. Matter, the assistant built into the platform, uses the same nodes natively. Running them here rather than as a local tool also means they work on a schedule or a trigger with nobody present, chain with every other connector in one workflow, hold the application key in a shared workspace credential store rather than in an individual's config, and carry destructive flags you can gate on.
Why does a stored credential sometimes need to re-authorize?
Because B2 auth is a two-step exchange rather than a single stored value. The application key id and application key you paste authenticate exactly one call, sent as HTTP Basic to a fixed host, and that call returns an authorization token valid for at most 24 hours plus the API host for the cluster your account lives on, which Backblaze assigns per account. Every other request uses that derived token against that derived host. Mattering runs the exchange for you and caches the result, refreshing well inside the token's lifetime, deliberately, so that a key revoked in the Backblaze console stops working quickly rather than up to a day later. If a token does expire mid workflow, the connector re-authorizes once and replays the request, re-reading the host from the fresh authorization rather than only the token, which is Backblaze's own documented advice. It retries once rather than in a loop, so a genuinely bad key surfaces as an error instead of hammering the auth endpoint.
What is the difference between hiding a file and deleting it?
This is the single most important thing to get right on B2, because getting it backwards either destroys data or leaves an unbounded bill. Backblaze B2: Hide File is not a delete. It writes a new version that is a hide marker, after which the name returns 404 on download and disappears from the file name listing, while every earlier version still exists, is still reachable by id, still appears in the version listing, and is still billed. Hiding reclaims no storage. It is reversible either by uploading a new version of the name or by deleting the hide marker, which is itself a version with its own id. Backblaze B2: Delete File Version is a real delete of ONE version, described by Backblaze as removing the version and all of its data as if it had never been uploaded. If older versions exist, the next most recent silently becomes the one served by name, so removing a file completely means running it over every version from the version listing. The S3 instinct to delete an object by name maps to hiding here, not to deleting.
Can an AI agent delete something I cannot get back?
Four nodes are flagged destructive so you can gate them, and they are not equally dangerous. Backblaze B2: Delete File Version is the one that loses data, permanently and per version. Backblaze B2: Delete Bucket refuses unless the bucket contains no version of any file, including hide markers and unfinished large files, so it fails rather than quietly destroying something forgotten; what it does lose is the bucket's configuration and its name, which is globally unique across all of Backblaze and may be taken by someone else once released. Backblaze B2: Cancel Large File discards every part uploaded to an unfinished large file and nothing else, since such a file was never visible in the bucket, so the scary-sounding one is the smaller risk. Backblaze B2: Delete Application Key touches no data at all and is irreversible for a different reason: the key's secret half was shown once at creation, so it can only be replaced, and everything using it starts failing immediately. Two reversible-looking nodes deserve the same gating: lifecycle rules on the bucket writes schedule irreversible deletion days later, and compliance retention cannot be removed by anyone until it expires.
How large a file can this handle?
Uploads through Backblaze B2: Upload File are capped at 100 MB, which is also Backblaze's recommended part size, and the node prefers a content URL that the runner fetches over bytes pasted into a canvas field. Larger files go through the large file family: start the file, upload parts numbered from 1 upwards, contiguous and starting at 1, then finish with every part's checksum in order. Backblaze B2: Upload Part composes fetching a part upload URL with the upload itself and retries once on a fresh URL, matching the vendor's guidance that on certain failures you request a new upload URL rather than backing off. Downloads through the two download nodes are capped at 256 KB of raw bytes, always reporting the true size and whether the read was truncated, so a clipped read is never mistaken for a whole one. For anything bigger, mint a download authorization and hand the URL to a worker that can stream it.
Does it use the S3-compatible API?
No, and that is a decision rather than a shortfall. B2's native API is complete on its own: it lists, reads, writes, copies, hides, deletes and does multipart, so an S3 plane would be a second way to do what these nodes already do, and every object workflow would ship with two nodes that look interchangeable and are not. The S3 surface is also strictly less capable on B2, where master application keys cannot be used with it at all and several features have no equivalent, and application key management has no S3 counterpart. The decisive reason is the delete semantics: an S3 delete by name removes only the latest version, which is not what that phrase means natively, and offering both would put two different delete semantics behind similarly named nodes on the connector where delete semantics are already the sharpest edge. Backblaze B2: Get Account Info does return the account's S3 host, so a generic HTTP node can reach that surface deliberately.
What does the API cost to call?
Backblaze's pricing page states that Class A, B and C transactions are free for pay-as-you-go customers, and every native endpoint this connector calls is Class A, B or C, which is why a full run of the catalogue costs nothing in transaction terms. Storage and egress are billed separately and their rates change, so check the pricing page rather than a number quoted anywhere else, including here. One class is worth separating out because it is easy to attribute wrongly: Class D covers outbound Event Notification deliveries rather than API calls, so a bucket whose notification rules fire often is billed for those deliveries even though reading and writing the rules is not.
Is there a B2 trigger for new files?
Not as a node in this connector. B2 does have Event Notifications, and Backblaze B2: Get Bucket Notification Rules and Backblaze B2: Set Bucket Notification Rules manage them, including which events fire, the prefix each rule watches, the target URL and custom headers, and whether Backblaze has suspended a rule. So a rule can be pointed at a webhook trigger in your workflow and configured from the canvas. Two things to know before you do. Setting the rules is a whole-list write rather than a merge: any rule left out is removed and its webhook stops firing immediately, so read the current set first and write the edited list back. And those two endpoints answer with a top-level JSON array, which nothing else in this API does, so downstream paths look different from every other node's.
Put Backblaze B2 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. Backblaze B2 is a product of its respective owner; Mattering is an independent platform.