A PocketBase MCP that points at your own server
40 nodes across records, collections, backups, settings, logs, files, cron jobs and realtime. PocketBase has no vendor cloud, so the instance URL lives on the credential and every node runs against the server you operate. 15 nodes read, 25 act, 9 are flagged destructive, and 27 need a superuser identity rather than an ordinary user.
What the PocketBase MCP connector does
PocketBase is an open source backend that ships as a single executable: an embedded SQLite database, a REST API, realtime subscriptions, built-in auth management and a dashboard, under the MIT licence. There is no PocketBase company running it for you. Every install is somebody's own server, which is the fact that shapes this connector from end to end.
The PocketBase connector for Mattering Automations is 40 nodes on that API. Records and collections cover the data and the schema. Backups cover create, upload, list, download, delete and restore. Settings covers instance configuration, the SMTP and S3 tests, and the Apple client secret generator. Logs and the health check cover observability. Files, cron jobs and realtime cover the rest. Fifteen nodes read and twenty five act.
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 read a collection with PocketBase: List Records, reason about what it found, and write back with PocketBase: Update Record, while the same nodes sit on a scheduled workflow that runs with nobody present.
Because there is no hosted PocketBase, the base URL is a credential field rather than something the connector knows. One credential is one instance. Paste the root URL of your server, the dashboard URL you copied from the browser, or a bare hostname, and the connector reduces it to the origin, since every path it calls is absolute from /api. Plain http is refused outright: this credential holds a password that is exchanged for a token on every cold start, and a password in the clear on the wire is interceptable. An instance that is genuinely reachable only over http needs a TLS-terminating proxy or a tunnel in front of it before it can be connected here.
PocketBase issues no API keys. Authentication is an exchange: you post an identity and a password to an auth collection and get back a signed token, which is then sent as the raw Authorization header PocketBase's own documentation specifies. The connector performs that exchange for you, caches the token for thirty minutes, and logs in again once when a request comes back 401. Nothing about the token is stored on the PocketBase side, which is worth knowing before you plan anything security-shaped: PocketBase documents that there are no sessions in the traditional sense and that tokens are not stored in the database, so an individual token cannot be revoked. Invalidating superuser tokens means changing the superuser password.
The single most consequential choice on the credential is which collection you authenticate against. A superuser, from the system _superusers collection, ignores collection API rules entirely and can run all 40 nodes. An ordinary auth record, from a collection such as users, is subject to that collection's list, view, create, update and delete rules, which is enough for the record nodes and the file token node and answers 403 on the other 27. Both are legitimate, and least privilege is a real reason to pick the second. Test Connection reports which one you got rather than guessing, because discovering it inside a workflow is the expensive version.
This connector is built against the API as PocketBase documents it today, which means the shape introduced in v0.23.0. That release was a breaking one: admins became system _superusers auth records and the separate /api/admins/ endpoints went away, and it added the batch endpoint, impersonation, collection truncate and the collection scaffolds endpoint that several nodes here depend on. An older instance will answer 404 on those paths, which reads like a wrong base URL if you do not know why. PocketBase's own repository also notes that full backward compatibility is not guaranteed before v1.0.0, so pin a version you have tested rather than assuming a node set is permanent.
PocketBase has no trash, no soft delete and no undo. The one recovery mechanism its documentation describes is a backup archive taken beforehand, a full ZIP snapshot of the pb_data directory including locally stored uploaded files. That is why nine nodes here are flagged destructive and why each of them names its own blast radius in the node itself rather than saying the word and leaving it there. PocketBase: Restore Backup is the widest of them: restoring replaces the instance's data with the archive and restarts the running PocketBase process.
One connection, three surfaces
- Visual automations. Drag PocketBase 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 PocketBase node, ready to drop on the canvas
40 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 15
PocketBase: Get Backup Download URL
Build a ready-to-use download URL for a stored backup archive. Superuser only. The endpoint returns raw ZIP bytes, which is not a useful node output, so this node returns the URL instead (the Appwrite download precedent) for a downstream HTTP node or a human to follow. PocketBase requires a short-lived superuser file token in the query string; leave 'token' blank and this node mints one for you from POST /api/files/token. The URL carries that token, so treat it as a secret and use it promptly.
PocketBase: Get Collection
Fetch one collection's full definition: its type, every field with its options, its indexes, and its five API rules (list, view, create, update, delete). Superuser only. A null rule means the operation is superuser-only; an empty-string rule means it is public.
PocketBase: Get Collection Scaffolds
Fetch empty skeleton definitions for each collection type (base, auth, view), including the system fields PocketBase always adds. Superuser only. Use this as the starting shape for PocketBase: Create Collection instead of hand-writing the field array, which is the most common source of a 400 on create.
PocketBase: Get File Download URL
Build the URL for a file stored on a record, optionally as a generated thumbnail. Returns the URL rather than the bytes, because raw image or document bytes are not a usable node output; hand the URL to an HTTP node, an email, or a human. Public collections need no token at all. For a collection with 'Protected' switched on, set mint_token and the node fetches a file token and appends it - treat that URL as a secret, since anyone holding it can read the file until the token expires.
PocketBase: Get Log
Fetch one log entry in full by id. Superuser only. Useful when PocketBase: List Logs was called with a narrow 'fields' selector and you now want the whole data object for a single entry.
PocketBase: Get Log Statistics
Hourly log counts as a bare array of {total, date} points. Superuser only. Apply the same filter expression you would use on PocketBase: List Logs to count only errors, only one route, or only one day. The series is bounded by log retention, so it cannot reach further back than settings.logs.maxDays.
PocketBase: Get Record
Fetch one record by id. Subject to the collection's View rule unless the credential is a superuser. Use 'expand' to pull related records inline in the same request rather than looping.
PocketBase: Get Settings
Read the instance settings: app metadata, SMTP, S3 storage and S3 backups, the automatic backup cron, log retention, the built-in rate limiter, the batch API caps and trusted-proxy handling. Superuser only. Secret values (SMTP password, S3 secret) come back MASKED, so this output can be logged but cannot be replayed straight back into an update.
PocketBase: Health Check
Ping the instance. The ONE endpoint in this connector that needs no authentication, which makes it the right probe for 'is the server up' as distinct from 'is my credential good'. Returns canBackup, which reports whether a backup can start right now - check it before PocketBase: Create Backup in an unattended workflow. Note the connector still performs its login exchange before calling this, so a 400 here means the credential failed, not the server.
PocketBase: List Backups
List the stored backup archives with their key, size in bytes and last-modified time. Superuser only. Returns a bare JSON array. This is the source of the backup picker on the delete, restore and download nodes, and the cheapest way for a workflow to assert that last night's automatic backup actually exists.
PocketBase: List Collections
List every collection on the instance with its fields, indexes and API rules. Superuser only. Takes no required parameters, so this is the connector's auth probe: run it first to confirm the instance URL and the credential work. It is also the source of the collection picker on every record node, so a workflow that discovers collections at runtime starts here.
PocketBase: List Cron Jobs
List the instance's registered cron jobs with their id and cron expression. Superuser only. Returns a bare JSON array. Includes PocketBase's own system jobs (log cleanup, database optimise, the automatic backup) alongside anything registered by a hook or a Go/JS extension, so it is the way to confirm a custom job actually loaded.
PocketBase: List Logs
List the instance's request and application logs, newest first, with paging and filtering. Superuser only. Each entry carries a level, a message and a data object holding method, url, status, execTime, referer, userAgent and the authenticated identity. This is a ROLLING BUFFER trimmed to settings.logs.maxDays (5 by default), not an archive - ship anything you need to keep somewhere else.
PocketBase: List Records
List or search the records of any collection, with paging, sorting, filtering and relation expansion. The workhorse read of the connector. A superuser credential sees everything; an ordinary auth-record credential sees only what the collection's List rule allows, and gets 403 when that rule is null. 'filter' takes PocketBase's expression syntax, not a search term.
PocketBase: Open Realtime Connection
Open the server-sent-events channel and read the PB_CONNECT event, which carries the clientId that PocketBase: Set Realtime Subscriptions needs. IMPORTANT: an SSE stream is a long-lived connection and an automation node is a request/response step, so this node reads only the first event and then CLOSES the stream. PocketBase drops a client after about five minutes with no activity and forgets its subscriptions, so the clientId this returns is short-lived and cannot be used to receive events inside a workflow. Use it to test that realtime is reachable, or to drive an external subscriber; do not build an event-driven workflow on it. For that, use a PocketBase hook or a scheduled PocketBase: List Records poll on a 'updated' filter.
Action nodes 25
PocketBase: Authenticate Record With Password
Exchange an end user's identity and password for that user's auth token, against any auth-type collection. This is how a workflow verifies a user's credentials or obtains a token to hand to a downstream system; it is NOT how this connector authenticates itself, which happens automatically from the saved credential. Returns {token, record}. Note PocketBase answers a wrong password with 400 'Failed to authenticate.', not 401. The issued token is a signed value the server does not store, so it cannot be revoked individually.
PocketBase: Batch Requests
DESTRUCTIVE (it can carry deletes). Run many record create/update/upsert/delete calls in ONE transaction: if any sub-request fails, every change in the batch is rolled back. That all-or-nothing property is the reason to use it over a loop. Flagged destructive because a batch may contain DELETE sub-requests, which are as permanent here as anywhere else in PocketBase. Requires batch to be ENABLED in Settings (it is off by default, and the maxRequests / timeout / maxBodySize caps apply); a disabled batch API answers 400.
PocketBase: Create Backup
Create a full backup archive of pb_data. Superuser only. NOT destructive, but not free either: the vendor documents that the application is put into READ-ONLY MODE while the ZIP is generated, and that this can be very slow on databases of a few GB or more, so do not schedule it in front of latency-sensitive work. Returns 204 with an empty body; poll PocketBase: List Backups to see the new key. Run this before any destructive node in this connector - it is the only recovery path PocketBase has.
PocketBase: Create Collection
Create a collection: a real SQLite table with a schema, indexes and API rules. Superuser only. Start from PocketBase: Get Collection Scaffolds to get a correctly shaped skeleton for the type you want rather than hand-writing the field array. Reversible: deleting the collection afterwards removes it and everything in it.
PocketBase: Create Record
Create a record. The body is a free-form object because a collection's schema is defined by the operator, not by PocketBase: read the field names from PocketBase: Get Collection (data.fields[].name). For an auth collection you must send password and passwordConfirm alongside the identity field. Reversible: PocketBase: Delete Record removes it. File fields cannot be filled here - this node sends JSON, and file uploads need a multipart request.
PocketBase: Delete Backup
DESTRUCTIVE AND IRREVERSIBLE. Delete a stored backup archive. Superuser only. The instance's live data is untouched, but if this archive was the last copy of some earlier state then that state becomes unrecoverable - which is exactly the situation backups exist to prevent. Download it first (PocketBase: Get Backup Download URL) if you are not certain. Returns 204 with an empty body.
PocketBase: Delete Collection
DESTRUCTIVE AND IRREVERSIBLE. Delete a collection AND every record in it - the SQLite table is dropped. Superuser only. There is no trash and no soft delete anywhere in PocketBase; the only recovery is a backup taken beforehand (PocketBase: Create Backup, then Restore Backup, which replaces the whole instance). The call is refused while another collection holds a relation field pointing at this one, and system collections cannot be deleted at all. Returns 204 with an empty body.
PocketBase: Delete Record
DESTRUCTIVE AND IRREVERSIBLE. Permanently delete one record. PocketBase has no trash and no soft delete: the row is gone the moment this returns, and the only recovery is a backup taken beforehand. Any file attached to the record is deleted from storage with it, and relation fields in OTHER collections that were configured with cascade delete will lose their records too. Returns 204 with an empty body.
PocketBase: Dry Run View Query
Run a SQL SELECT against the instance database inside a rolled-back transaction and get back the field definitions it would produce plus a sample row. Superuser only. This is the only place in PocketBase's REST API that accepts SQL. It is intended for validating a view collection's query before creating it, and because the transaction is rolled back it is safe to explore with - but it is still arbitrary SQL against production data, so treat the query field as privileged and never build it from untrusted input. The statement must be a SELECT that projects a column aliased 'id'.
PocketBase: Generate Apple Client Secret
Mint the signed JWT that Apple requires as the client secret for Sign in with Apple. Superuser only. Apple caps these at six months, so the practical use is a scheduled automation that regenerates the secret and writes it back with PocketBase: Update Settings before the old one expires. Nothing is stored by this call - it returns the secret and forgets it.
PocketBase: Get File Token
Mint a short-lived file token for the connector's own identity. Needed to read files in collections whose 'Protected' option is on, and to download backup archives. Works for a superuser or for an ordinary auth record. Nothing is stored and nothing is changed; the token simply expires. PocketBase: Get File Download URL and PocketBase: Get Backup Download URL both mint one automatically when you leave their token field blank, so call this node directly only when you need to hand the token to something else.
PocketBase: Impersonate User
Mint a non-renewable auth token for a specific user record, without their password. SUPERUSER ONLY - an ordinary auth-record credential gets 403. Use it when a workflow must act AS a user so the collection's API rules apply to it, instead of acting as a superuser that bypasses them. Set a short duration; the token cannot be refreshed and cannot be revoked once issued, because PocketBase does not store tokens.
PocketBase: Import Collections
DESTRUCTIVE. Bulk-import a collections snapshot, creating and updating collections in one transaction. Superuser only. With deleteMissing = true this becomes a full REPLACE: every collection absent from the payload is deleted with all of its records, and any field missing from an imported collection is dropped with its data. Irreversible; recovery only from a backup taken beforehand. Leave deleteMissing false for an additive import. Returns 204 with an empty body.
PocketBase: Request Password Reset
Send PocketBase's password-reset email to one address in an auth collection. The reset itself is completed by the user clicking the emailed link, so a workflow can start the flow but cannot finish it. Requires SMTP to be configured in Settings (verify with PocketBase: Send Test Email first). Always returns 204 whether or not the address exists, which is deliberate: it stops the endpoint being used to enumerate accounts, and it means a success here does NOT prove mail was sent.
PocketBase: Restore Backup
DESTRUCTIVE AND IRREVERSIBLE - the widest-blast-radius node in this connector. Superuser only. Restoring REPLACES THE ENTIRE INSTANCE: the current pb_data directory (every collection, every record, every uploaded file, all settings and all superusers) is swapped for the archive's contents and the application restarts. Everything written since that archive was taken is lost, and PocketBase documents no undo for it - the only way back is to have run PocketBase: Create Backup immediately beforehand, which is the recommended first step of any restore workflow. Expect the connection to drop while the app restarts, so a 5xx or a transport error here does not by itself mean the restore failed. Returns 204 with an empty body.
PocketBase: Run Cron Job
Trigger a registered cron job immediately, without waiting for its schedule. Superuser only. Runs SYNCHRONOUSLY and returns 204 only when the job has finished, so a long job can hold the request open. The job's own effects are whatever it does - triggering __pbLogsCleanup__ deletes old logs for real - so read the job before firing it. A 404 means the id is not registered.
PocketBase: Send Test Email
Send one of PocketBase's own transactional templates to an address you choose, to prove SMTP works. Superuser only. This delivers REAL, unrecallable mail, so point it at your own address; it is not flagged destructive because it changes no stored data. Returns 204 on success, and a 400 whose body names the SMTP failure otherwise - which makes it the fastest way to diagnose why PocketBase: Request Password Reset appears to do nothing.
PocketBase: Set Realtime Subscriptions
Set the topics an already-connected SSE client is subscribed to. Sending an empty subscriptions array unsubscribes it from everything. This is the call at which PocketBase applies authorization, so the credential's identity decides which topics are allowed - a topic the collection's rules do not permit is rejected here, not at connect time. Only meaningful against a clientId from a connection that is still open, which the companion node's own stream is not; this node exists for driving an EXTERNAL subscriber whose clientId was handed to the workflow. Returns 204 with an empty body.
PocketBase: Test S3 Connection
Check that the configured S3 credentials actually work, for either the file-storage filesystem or the backups filesystem. Superuser only. Writes and removes a probe object, so it changes nothing that survives the call. Returns 204 on success; on failure the 400 body names what the bucket rejected. Run it after PocketBase: Update Settings and before trusting an S3 backup schedule.
PocketBase: Truncate Collection
DESTRUCTIVE AND IRREVERSIBLE. Delete EVERY record in a collection while keeping the collection itself. Superuser only. Cascade delete rules on related collections still run, so this can take rows out of OTHER collections too. No trash, no undo; recovery only from a backup taken beforehand. Returns 204 with an empty body.
PocketBase: Truncate Logs
DESTRUCTIVE AND IRREVERSIBLE. Delete EVERY log entry on the instance. Superuser only. Logs live in their own database file and are NOT covered by an ordinary backup's usefulness here - once truncated, the request history is gone and there is no undo. Application data is untouched. Returns 204 with an empty body.
PocketBase: Update Collection
DESTRUCTIVE. Update a collection's schema, indexes or API rules. Superuser only. The 'fields' array is REPLACED, not merged: any field you omit is dropped from the table and its stored column data goes with it, permanently and with no undo. Always send the full field array (fetch it with PocketBase: Get Collection first). Renaming a field preserves its data only when you keep its id and change its name; a same-named field with a new id is a drop-and-add. Recovery exists only if a backup was taken beforehand.
PocketBase: Update Record
Update a record. PATCH semantics: only the keys you send are written, the rest are left alone. Multi-value fields support the + modifiers PocketBase documents ("tags+" appends, "+tags" prepends, "tags-" removes). Changing an auth record's password requires oldPassword unless the credential is a superuser.
PocketBase: Update Settings
Update instance settings. Superuser only. Merge semantics: only the top-level groups you send are touched, but each group you DO send replaces its whole sub-object, so read the current value with PocketBase: Get Settings and edit it rather than sending a partial group. Not flagged destructive - nothing is deleted - but it is the node most able to break an instance: turning off SMTP silences password resets, and a wrong rateLimits rule can throttle your own automations. Returns the updated settings.
PocketBase: Upload Backup
Upload an existing backup ZIP into the instance's backup store, so it can later be restored. Superuser only. Uploading does NOT restore anything - it only files the archive - which is why this is a reversible write and PocketBase: Restore Backup is not. The node fetches the archive from an https URL and forwards it as multipart/form-data (PocketBase has no upload-from-URL variant), capped at 200 MB. Returns 204 with an empty body.
Connecting PocketBase takes one credential
Everything comes from the PocketBase server you run. There is no vendor account to sign up for, no API key page and no billing tier: PocketBase is MIT-licensed software you host yourself. You need four values. The base URL is your instance root, for example https://pocketbase.example.com, and it must be https. The auth collection decides your identity: _superusers is the default and is what the Collections, Backups, Settings, Logs, Crons, SQL and impersonation nodes require, while an auth-type collection such as users gives a least-privilege credential that reaches the record and file nodes only. The identity is whatever the collection accepts to log in with, which is the email address by default and can be a username or another unique field where the collection is configured that way, and the password is that account's password. Superusers are managed from the dashboard PocketBase serves at /_/ on your instance.
Decide which identity the connection should hold before you create anything. A superuser bypasses every collection API rule and unlocks all 40 nodes; an ordinary auth record is bound by that collection's rules and will answer 403 on 27 of them. If the workflow only reads and writes records, the second is the safer choice and is fully supported.
Create the account in PocketBase. Superusers are managed from the dashboard PocketBase serves at /_/ on your instance. For a least-privilege credential, create a record in an auth-type collection and check that the collection's list, view, create, update and delete rules actually allow what the workflow needs. PocketBase locks all five rules to superusers by default, so a new collection grants an ordinary user nothing until you write them.
Make sure the instance is reachable over https from the internet, not just from your own machine. This connector refuses http, so a local instance on localhost cannot be connected directly; put it behind a TLS-terminating reverse proxy or an https tunnel and use that hostname. PocketBase can also issue a Let's Encrypt certificate itself when you start it with a domain name.
In Mattering Automations, open Connectors, click Add Connector and choose PocketBase, then create a new credential. Fill base_url with your instance root, auth_collection with _superusers or the auth collection you chose, and the identity and password for that account. Anything pasted after the hostname is trimmed, so the dashboard URL out of your browser bar works as well as a clean origin.
Click Test Connection. It does three things in order, and each one rules out a different failure: an unauthenticated call to /api/health proves the URL really is a PocketBase instance rather than a proxy or a parked domain, the login exchange proves the identity and password, and a superuser-only read of the collections list classifies the identity. The result says explicitly whether you are connected as a superuser or as an ordinary record, and reports the canBackup flag from the health response.
All 40 PocketBase nodes appear in the canvas palette. Run PocketBase: List Collections first: it needs no configuration, and it is the node that feeds the collection picker on every record node, so a working list means the pickers will populate too.
Common uses for the PocketBase MCP
A backup that is verified rather than assumed
PocketBase's automatic backup schedule is a setting, not a report, and nothing tells you when it silently stops producing archives. A scheduled workflow can check instead of hoping. PocketBase: Health Check reports canBackup, which is whether a backup can start right now. PocketBase: Create Backup takes the archive, and PocketBase: List Backups returns the stored archives with their key, size and last-modified time, so a workflow can assert that last night's archive exists and is not zero bytes, then open a task or send a message when it does not. PocketBase: Get Backup Download URL builds a link for shipping an archive off the box, which matters because the archive lives on the same server as the data it protects.
Reading and writing your application's own records
PocketBase: List Records is the workhorse. It pages, sorts, filters and expands relations, and the filter field takes PocketBase's expression syntax rather than a search term, so status = "published" && created >= "2026-01-01" is a query and a bare keyword is a 400. PocketBase: Get Record fetches one by id and can expand its relations in the same call instead of looping. PocketBase: Create Record and PocketBase: Update Record take a free-form JSON body, because a collection's schema is yours rather than PocketBase's; read the field names from PocketBase: Get Collection. Update is a PATCH, so only the keys you send are written.
Promoting a schema between two instances
Staging and production are two separate PocketBase servers, which means two credentials and two connectors in the same workspace. PocketBase: List Collections reads the whole schema from one, and PocketBase: Import Collections writes it into the other in a single transaction. Leave deleteMissing false and the import is additive. Setting it true makes the import a full replace: every collection absent from the payload is deleted with its records, and any field omitted from an imported collection is dropped with its data. PocketBase: Create Backup on the target immediately before is not a formality here, because it is the only way back.
Transactional writes that either all land or none do
PocketBase: Batch Requests runs many record creates, updates, upserts and deletes in one transaction, and rolls the whole thing back if any sub-request fails. That all-or-nothing property is the reason to use it instead of a loop of individual nodes, particularly when a partial write would leave the application in a state nobody wrote code for. Two things to know before you build on it: the batch API has to be explicitly enabled in the dashboard under Settings, because it is off until you turn it on, and the node is flagged destructive because a batch can carry deletes, which are as permanent inside a transaction as anywhere else in PocketBase.
Watching an instance you cannot log into every morning
PocketBase: List Logs reads request and application logs newest first, with the same filter expression syntax as records, so level >= 4 || data.status >= 400 isolates the entries worth a human's attention. PocketBase: Get Log Statistics returns hourly counts as points, which is the cheap way to spot a spike without pulling every row. PocketBase: Get Log opens one entry in full. A scheduled digest that summarises error counts, checks canBackup and confirms last night's archive turns a self-hosted instance into something that reports on itself. How far back the log window reaches is whatever retention the instance is configured with, so ship anything you want to keep somewhere durable.
User administration without handling passwords
PocketBase: Request Password Reset starts PocketBase's own reset email for one address, which is the offboarding and support-flow half a workflow can legitimately drive; the user finishes it from the emailed link. It always returns 204 whether or not the address exists, which is deliberate anti-enumeration behaviour and means success here does not prove mail was sent, so verify SMTP with PocketBase: Send Test Email, whose failure body names the actual problem. PocketBase: Impersonate User mints a short-lived token for a specific user so a workflow can act as them and have the collection's API rules apply, rather than acting as a superuser that ignores them. Keep the duration short: PocketBase does not store tokens and cannot revoke one.
Example: A nightly backup and health report for a self-hosted instance
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. This connector has no trigger nodes. PocketBase's realtime channel is a long-lived SSE stream and an automation node is a request and a response, so PocketBase workflows run on a schedule or on a trigger from somewhere else rather than listening for a push.
PocketBase: Health Check runs first. It needs no authentication on the PocketBase side and reports canBackup, so a false here stops the run before it asks for an archive that cannot be produced.
PocketBase: Create Backup takes the archive. It returns 204 with an empty body rather than the archive's name, and it fails if another backup or restore is already in progress, so the workflow treats a failure here as the alert rather than as noise.
PocketBase: List Backups reads the store back and confirms the new key exists with a plausible size and a timestamp from the last few minutes. This is the step that turns an assumption into a check.
PocketBase: Get Backup Download URL builds a link with a file token in it, and an HTTP step copies the archive to object storage somewhere other than the instance. Treat that URL as a secret and use it immediately: PocketBase file tokens are documented as valid for about two minutes.
PocketBase: Get Log Statistics pulls hourly counts filtered to server errors, and a Mattering Productivity task or a message carries the night's summary to a person. Nothing in this workflow deletes anything, which is deliberate: pruning old archives with PocketBase: Delete Backup belongs in a separate flow that a human approves.
PocketBase MCP questions, answered
What can this connector actually do in PocketBase?
40 nodes: 15 read and 25 act. Collections covers list, get, create, update, delete, truncate, import and the scaffolds helper. Records covers list, get, create, update, delete, batch requests, authenticating a user with a password, impersonating a user and requesting a password reset. Backups covers list, create, upload, download URL, delete and restore. Settings covers read, update, the S3 connection test, the SMTP test email and the Apple client secret generator. Logs covers list, get, statistics and truncate, plus the unauthenticated health check. Files covers minting a file token and building a file download URL. Crons covers listing and running jobs, and realtime covers opening the SSE channel and setting subscriptions. One node, PocketBase: Dry Run View Query, runs a SQL SELECT inside a rolled-back transaction. Not included and worth knowing before you plan: OAuth2 and one-time-password sign-in flows, the confirm halves of verification, password reset and email change, because each consumes a token delivered to a human; uploading files onto records, which needs a multipart request PocketBase types per collection; streaming the actual bytes of a file or an archive, since the two download nodes return a URL instead; and any trigger or webhook surface, which PocketBase's REST API does not offer.
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 your PocketBase instance 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 a workflow an assistant helps you design then runs on a schedule with nobody present. Given that 27 of these nodes require a superuser identity that ignores every collection API rule, the sensible split is to hand an assistant the read nodes and keep the writes, especially the nine destructive ones, behind a condition or an approval step. A least-privilege credential pointed at an ordinary auth collection is the stronger version of the same idea, because it makes the restriction structural rather than a matter of prompt discipline.
Does PocketBase publish its own MCP server?
No. PocketBase ships no first-party MCP server, and MCP is not mentioned in its documentation or in its repository README. So there is no vendor alternative to weigh here, and the honest framing is what running PocketBase through Mattering adds rather than what it replaces: the nodes run on a schedule or from a trigger with nobody present, they chain with every other connector in one workflow so a PocketBase record can become a task, a message or a row in another system, the credential is held once in a shared workspace store rather than in each person's local config, and the nine nodes that can destroy data carry destructive flags rather than sitting undifferentiated beside the reads.
What is the base URL, and why can I not use http or localhost?
There is no api.pocketbase.com. PocketBase is self-hosted software with no vendor cloud, so the API root is whatever host you run, and it lives on the credential rather than in the connector. One credential is one instance, and connecting a staging server and a production server means two credentials. The connector reduces whatever you paste to its origin, so a bare hostname, a trailing slash, a URL ending in /api, and the dashboard URL copied from your browser all resolve to the same place. Plain http is refused rather than warned about: this credential holds a password that is exchanged for a token on every cold start, so it crosses the wire repeatedly rather than once at setup, and a password sent in the clear is interceptable. That does mean a bare localhost instance cannot be connected. Put it behind a TLS-terminating reverse proxy or an https tunnel and use that hostname, or start PocketBase with a domain name and let it issue a Let's Encrypt certificate.
What is the difference between a superuser credential and a normal one?
It decides which half of the connector works, and it is the setting most worth getting right before you build anything. PocketBase's superusers live in the system _superusers collection and, in PocketBase's own words, can access and modify anything because collection API rules are ignored for them. An ordinary record in an auth-type collection such as users is subject to that collection's five API rules, and PocketBase locks all five to superusers by default, so a new collection grants an ordinary account nothing until somebody writes rules. In this connector, a superuser can run all 40 nodes. An ordinary auth record can run the record nodes, within its rules, plus PocketBase: Get File Token and the file download URL builder, and gets 403 on the other 27: every Collections, Backups, Settings, Logs and Crons node, the SQL dry run, and PocketBase: Impersonate User. Test Connection tells you which you have rather than leaving you to find out mid-workflow, and both are supported on purpose, because a workflow that only touches records should not be holding an identity that can drop tables.
What are PocketBase's rate limits?
Whatever you set, and nothing otherwise. There is no vendor quota to design around, because there is no vendor: PocketBase v0.23.0 and later ship a built-in rate limiter, and PocketBase's production guide describes it as something to enable and configure in the dashboard, alongside the option of using an external limiter through a reverse proxy. So the only limits your automations meet are the ones the instance's own operator configured, which may well be you. That cuts both ways worth knowing about: PocketBase: Update Settings can change those limiter rules, and a rule written too tightly will throttle your own workflows. If you run PocketBase behind a reverse proxy, set trusted-proxy handling too, or the limiter and the log IPs will all see the proxy's address rather than the caller's.
Which PocketBase versions does this connector work with?
It is built against the API as PocketBase documents it now, which is the shape introduced by v0.23.0. That release was explicitly a breaking one: admins became system _superusers auth records and the separate /api/admins/ endpoints were removed, which is why the credential's auth collection defaults to _superusers rather than to an admins endpoint. v0.23.0 also added several endpoints this connector uses directly, including POST /api/batch, the impersonation endpoint, collection truncate at DELETE /api/collections/{collection}/truncate, and the scaffolds helper at GET /api/collections/meta/scaffolds. On an instance older than that, those nodes answer 404, which is easy to misread as a wrong base URL. PocketBase's repository also states that full backward compatibility is not guaranteed before v1.0.0, so treat the node set as matched to a version you have actually tested rather than as permanent, and read the changelog before upgrading a server that automations depend on.
What happens when a workflow deletes something in PocketBase?
It is gone. PocketBase has no trash, no soft delete and no restore endpoint; the only recovery its documentation describes is a backup archive taken beforehand, which is a full ZIP snapshot of the pb_data directory including locally stored uploaded files. Nine nodes are flagged destructive on that basis and each names its own cost. PocketBase: Delete Record takes one row, deletes files attached to it from storage, and can take rows out of other collections through cascade-delete relations. PocketBase: Delete Collection drops the table and everything in it. PocketBase: Truncate Collection empties a collection and still fires cascade rules elsewhere. PocketBase: Update Collection is the least obvious of them: its fields array replaces rather than merges, so a field omitted from the payload is dropped with its stored column data, which is why the honest pattern is to read the current array with PocketBase: Get Collection and edit it. PocketBase: Import Collections with deleteMissing set becomes a whole-schema replace. PocketBase: Truncate Logs clears the request history, which an application backup does not bring back. PocketBase: Delete Backup leaves live data alone but can remove the last copy of an earlier state. And PocketBase: Restore Backup replaces the instance's data with the archive and restarts the running PocketBase process, so everything written since that archive was taken is lost.
Put PocketBase 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. PocketBase is a product of its respective owner; Mattering is an independent platform.