Menu

Mattering Automations PocketBase integration

Connect your self-hosted PocketBase instance to Mattering Automations: records, collections, backups, settings, logs, files, cron jobs and realtime as workflow steps, authenticated by an identity and password exchanged for a PocketBase auth token against your own server.

The Mattering Automations PocketBase integration puts your own PocketBase server on the automation canvas: list, read, create, update and delete records in any collection, manage collections and their API rules, take and restore backups, read and change instance settings, read request logs, mint file tokens and download URLs, list and run cron jobs, and open the realtime channel. Forty nodes in total, fifteen that read and twenty five that act.

PocketBase is different from every other connector in this documentation in one structural way: there is no vendor cloud. PocketBase is MIT-licensed software that ships as a single executable with an embedded SQLite database, a REST API, built-in auth and a dashboard, and every install is somebody's own server. So the API root is not something this integration knows. It is a field on the credential, alongside the identity and password of an account on that instance, and one credential means one instance.

Two things follow that are worth reading now rather than hitting later. The connection is over https only, because the credential holds a password that is exchanged for a token on every cold start rather than once at setup, which means a local instance on localhost needs a tunnel or a TLS-terminating proxy before it can be connected. And which collection you authenticate against decides which half of the integration works: a superuser ignores every collection API rule and can run all 40 nodes, while an ordinary auth record is bound by that collection's rules and answers 403 on 27 of them. Both are supported deliberately. This guide covers both, and ends with the complete node reference.

Before you start

  • A running PocketBase instance that you operate. There is no account to create with a vendor and no plan to choose: PocketBase is open source software under the MIT licence, distributed as a prebuilt executable you run yourself. Its superuser dashboard is served at /_/ on the instance.
  • PocketBase v0.23.0 or newer. That release was a breaking one and this integration is built against the API shape it introduced: admins became system _superusers auth records and the separate /api/admins/ endpoints were removed, and v0.23.0 added the batch endpoint, impersonation, collection truncate and the collection scaffolds endpoint that several nodes here call directly. On an older instance those nodes return 404.
  • The instance reachable over https from the internet. This integration refuses plain http, so a bare localhost instance cannot be connected as-is. Put it behind a TLS-terminating reverse proxy or an https tunnel, or start PocketBase with a domain name so it issues a Let's Encrypt certificate itself.
  • An account on the instance to authenticate as, and a decision about which kind. A superuser in the system _superusers collection unlocks all 40 nodes. A record in an auth-type collection such as users is a least-privilege credential that reaches the record and file nodes only. Neither is a workaround for the other.
  • For a least-privilege credential, API rules that actually allow the work. PocketBase locks a collection's list, view, create, update and delete rules to superusers by default, so a new collection grants an ordinary account nothing until somebody writes them.
  • The batch API enabled in the dashboard, if you intend to use PocketBase: Batch Requests. PocketBase documents the batch Web API as something that has to be explicitly enabled and configured under Settings > Application, so the node returns 400 until you turn it on.
  • SMTP configured on the instance, if you intend to use PocketBase: Request Password Reset. Verify it with PocketBase: Send Test Email first, because the reset endpoint returns 204 whether or not mail was sent.
  • A Mattering workspace with access to the Automations app.

Collect four values from your PocketBase instance

PocketBase issues no API keys. Authentication is an exchange: a caller posts an identity and a password to an auth collection and receives a signed token, which is then sent back on every request as the raw Authorization header PocketBase's documentation specifies. Mattering performs that exchange for you and caches the token, so what you store is the identity and password, plus the address of your server and the collection to authenticate against. Nothing here is fetched from a vendor portal, because there is no vendor.

Note your instance root URL, for example https://pocketbase.example.com. It must be https. Anything after the hostname is trimmed, so the dashboard URL copied out of your browser bar works as well as a clean origin, and so does a bare hostname.
Plain http is refused rather than warned about. This credential holds a password, and PocketBase exchanges it for a token on every cold start, so it crosses the wire repeatedly rather than once at setup. If your instance is only reachable over http today, put a TLS-terminating proxy or an https tunnel in front of it before you connect.
Decide the auth collection. Use _superusers for full access to all 40 nodes. Use an auth-type collection such as users for a least-privilege credential limited to the record and file nodes.
Create or identify the account. Superusers are managed from the dashboard PocketBase serves at /_/ on your instance; ordinary accounts are records in an auth-type collection such as users.
Note that account's identity and password. 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 if the collection is configured that way.
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 and there is no logout endpoint. To invalidate superuser tokens you change the superuser password. That is the lever to reach for if a credential is ever exposed.

Connect PocketBase to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose PocketBase from the list, then click Create new credential.
Fill base_url with your instance root, auth_collection with _superusers or the auth collection you chose, and identity and password with that account's login. The credential is stored encrypted and never appears in workflow logs.
Click Test Connection. It runs three checks in order, and each rules out a different failure. An unauthenticated call to /api/health proves the URL really is a PocketBase instance rather than a proxy, a parked domain or a dashboard-only route. The login exchange proves the identity and password. A superuser-only read of the collections list then classifies the identity you actually hold.
Read the success message rather than just the tick. It states explicitly whether you connected as a superuser, with every node available, or as an ordinary auth record, with the Collections, Backups, Settings, Logs, Crons, SQL and impersonation nodes returning 403. It also reports the canBackup flag from the health response, which is worth knowing before you schedule a backup workflow.
All 40 PocketBase nodes appear in your canvas palette.

Verify it works

Open any automation canvas and check the palette: a PocketBase section should list the read and action nodes. Drop PocketBase: List Collections onto the canvas and run a test step without changing anything. It is the integration's natural probe because it takes no required configuration, and it is also the node that feeds the collection picker on every record node, so a working list means the pickers will populate too. It is superuser-only, so a 403 here is the expected answer for a least-privilege credential rather than a fault.

For a least-privilege credential, run PocketBase: List Records instead and pick your collection by name. What comes back is bounded by that collection's List rule rather than by the connection, so an empty page with a 200 usually means the rule is narrower than you thought, and a 403 means the rule is locked to superusers, which is PocketBase's default for a new collection.

Run PocketBase: Health Check as a third step. It is the one node in this integration that PocketBase does not require authentication for, which makes it the right way to separate a server problem from a credential problem later on. Its canBackup field also answers whether a backup could start right now. Everything in this verify path is read-only, so it cannot reach any of the nine destructive nodes and is safe to re-run whenever you want to check the connection.

Node reference

40 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 15

PocketBase: Get Backup Download URL

pocketbase_download_backup

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

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

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

pocketbase_download_file

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

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

pocketbase_get_log_stats

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

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

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

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

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

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

pocketbase_list_crons

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

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

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

pocketbase_realtime_connect

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

pocketbase_auth_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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pocketbase_run_cron

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

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

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

pocketbase_test_s3

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

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

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

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

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

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

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.

Using the integration

One credential is one instance

There is no api.pocketbase.com, so the API root lives on the credential. Practically that means a staging server and a production server are two credentials, and a node picks between them by which connection it uses rather than by a field. The base URL is normalized to its origin before every call, so a bare hostname, a trailing slash, a value ending in /api and the dashboard URL from your browser bar all resolve to the same place, and every path this integration calls is absolute from /api on that origin. The https requirement is a deliberate cost rather than an oversight: PocketBase has no API keys, so the credential holds a password and that password is exchanged for a token on every cold start of a worker process. Sending it over plain http would put it on the wire repeatedly in the clear. PocketBase can issue a Let's Encrypt certificate for a domain name you start it with, and its production guide covers running behind a reverse proxy if you would rather terminate TLS there.

Superuser or ordinary auth record, and what each can reach

PocketBase's superusers are records in the system _superusers collection, and PocketBase's own documentation says they can access and modify anything because collection API rules are ignored for them. An ordinary record in an auth-type collection is bound by that collection's five rules: listRule, viewRule, createRule, updateRule and deleteRule. A locked rule means only a superuser can perform the action and PocketBase makes that the default, while an empty-string rule means anyone can, including guests. In this integration, 27 of the 40 nodes require a superuser: every Collections node, every Backups node, every Settings node, every Logs node, both Crons nodes, PocketBase: Dry Run View Query and PocketBase: Impersonate User. The record nodes, the two Files nodes and the two Realtime nodes work with either identity, with an ordinary token subject to the rules. Each superuser-only node says so in its own description, so you do not have to hold this table in your head while configuring one. If a workflow only reads and writes records, an ordinary auth record is the better credential, because it makes the boundary structural rather than a matter of discipline.

Records, filters and the collection picker

PocketBase's record endpoints are dynamic per collection, in the same way Airtable's are per table, so the collection picker on every record node is fed by PocketBase: List Collections and shows each collection's type on its second line. That type matters: only auth-type collections accept PocketBase: Authenticate Record With Password and PocketBase: Impersonate User, and a view collection is read-only. The filter field is the other thing to get right. PocketBase's filter is an expression language of the form OPERAND OPERATOR OPERAND, not a search box: it supports =, !=, >, >=, < and <=, ~ and !~ for like and not-like, a ? prefix for any-of matching on multi-value fields, grouping with parentheses, and && and || to combine. So status = "published" && created >= "2026-01-01" is a query and a bare keyword is a 400. Paging is offset-style with page defaulting to 1 and perPage defaulting to 30, there is no cursor, and setting skipTotal skips the count query and returns -1 for totalItems and totalPages, which is faster on a large table and will break a workflow that branches on totalPages. Record ids are free text rather than a picker on purpose: PocketBase records are user-defined and no field is guaranteed to exist across collections, so a picker could only label rows by a random fifteen-character id.

Changing a schema without losing a column

PocketBase: Update Collection is flagged destructive and the reason is not obvious from its name. Its fields array replaces rather than merges, so any field you omit from the payload is dropped from the table and its stored column data goes with it. The safe pattern is always the same: read the current definition with PocketBase: Get Collection, edit that array, and send it whole. Renaming a field preserves its data only when you keep its id and change its name, because a same-named field with a new id is a drop and an add. Going the other way, PocketBase: Get Collection Scaffolds returns empty skeletons for the base, auth and view collection types including the system fields PocketBase always adds, which is the right starting shape for PocketBase: Create Collection and avoids the commonest cause of a 400 on create. PocketBase: Import Collections promotes a whole schema between two instances in one transaction, additively by default; setting deleteMissing turns it into a full replace in which every collection absent from the payload is deleted with its records.

Backups are the only undo PocketBase has

PocketBase has no trash, no soft delete and no restore endpoint for individual records. 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 but excluding local backups and anything already uploaded to S3. That single fact is why nine nodes here carry destructive flags and why PocketBase: Create Backup belongs at the front of any workflow that will delete, truncate, import or restore. Two operational details matter. Creating a backup returns an error when another backup or restore is already in progress, so a run that overlaps a scheduled backup fails rather than queueing. And PocketBase: Restore Backup restarts the running PocketBase process, so expect the connection to drop; a transport error or a 5xx from that node does not by itself mean the restore failed, and PocketBase: Health Check is the way to find out. PocketBase: Get Backup Download URL exists because the archive lives on the same server as the data it protects, so shipping it somewhere else is the point.

Files, tokens and why download nodes return URLs

The two download nodes return a URL rather than bytes, because raw image or archive bytes are not a usable node output. Pass the URL to an HTTP step, an email or a person. PocketBase: Get File Download URL builds the address of a file stored on a record, optionally with a thumbnail spec such as 100x100f or the download flag that makes a browser save rather than preview. Files in PocketBase are publicly accessible by default if you know the full URL, so for an ordinary collection no token is involved at all. A collection with the Protected option enabled needs a file token, which PocketBase: Get File Token mints and which the download nodes can mint for you. Two cautions travel with that. PocketBase documents file tokens as valid for about two minutes, so a URL that sat in a queue for ten will not work. And while it is valid, the URL is a bearer credential in its own right: anyone holding it can read the file, and PocketBase cannot revoke it. PocketBase: Get Backup Download URL always mints one, because a backup download always requires a superuser file token.

Realtime is not a trigger, and what to use instead

PocketBase has a realtime channel, and it is worth being precise about what this integration can do with it, because the honest answer is less than people expect. The channel is server-sent events: a long-lived stream. An automation node is a request and a response. PocketBase: Open Realtime Connection therefore reads the first event, which is the PB_CONNECT event carrying the client id, and then closes the stream. PocketBase documents that a connected client which receives no new messages for five minutes is sent a disconnect signal, so the client id that node returns is short-lived and cannot be used to receive events inside a workflow. Use it to prove realtime is reachable, or to drive an external subscriber that hands its client id to a workflow, which is what PocketBase: Set Realtime Subscriptions is for. Note where authorization happens: PocketBase applies it during the first set-subscriptions call rather than at connect, with a collection's View rule governing a single-record topic and its List rule governing a whole-collection topic, so a topic the rules do not permit is rejected there. For genuinely event-driven work, either write a PocketBase hook that posts to a webhook, or run a scheduled PocketBase: List Records filtered on updated. This integration ships no trigger nodes, and PocketBase's REST API offers no webhook surface to build them on.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. PocketBase publishes no MCP server of its own: MCP is not mentioned in its documentation or in its repository README, so there is no vendor alternative to weigh here. What running PocketBase through Mattering adds is that the same nodes are canvas steps, so a workflow an assistant helps you design then runs on a schedule with nobody present, chains with every other connector so a record can become a task or a message elsewhere, and holds the credential once in a shared workspace rather than in each person's local config. Scope the assistant deliberately. A superuser credential ignores every API rule in the instance, so handing an assistant the reads and keeping the writes, and especially the nine destructive nodes, behind a condition or an approval step is the baseline. Connecting with an ordinary auth-record credential instead is the stronger version, because the limit then lives in PocketBase rather than in a prompt.

Settings, logs and running an instance from a workflow

PocketBase: Get Settings reads 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. Secret values such as the SMTP password and the S3 secret come back masked, which means the output can be logged safely but cannot be replayed straight back into an update, since the masked value would overwrite the real one. PocketBase: Update Settings merges by top-level group but replaces within one, so read the group you want to change, edit it, and send it whole. It is not flagged destructive because it deletes nothing, but it is the node most able to break an instance: turning SMTP off silences password resets, and a rate-limiter rule written too tightly throttles your own automations. Verify after changing things rather than assuming: PocketBase: Send Test Email proves SMTP by sending real mail to an address you choose, and PocketBase: Test S3 Connection writes and removes a probe object against either the storage or the backups filesystem. On the observability side, all four log nodes are superuser-only, they accept the same filter expression syntax as records, and how far back the window reaches is whatever retention the instance is configured with, so ship anything you need to keep somewhere durable.

Troubleshooting

Test Connection fails with HTTP 400 and Failed to authenticate
This is a wrong identity or password, and the status code is the surprising part. PocketBase answers a bad login with 400, not the 401 most APIs return, because the failure happens at the login exchange rather than on an authenticated request. In this integration 401 appears only when a request carries a missing or malformed token, and 403 when a valid non-superuser token reaches a superuser-only route. So a 400 here means one of three things: the identity is not what that collection accepts to log in with, the password is wrong, or the account does not exist in the collection named in auth_collection. Check the collection first, because it is the easiest to get wrong: superusers live in _superusers, and ordinary users usually live in users. A 404 from the login step means there is no auth collection with that name at all.
Some nodes work and the Collections, Backups, Settings or Logs nodes return 403
The credential is valid and is not a superuser. That is a permissions fact rather than a stale token, which is why the connector does not retry it: a fresh login produces the same identity. 27 of the 40 nodes require a superuser, and an ordinary auth-record credential reaches the record nodes, the two Files nodes and the two Realtime nodes only. Open the credential and check auth_collection: if it names a collection such as users rather than _superusers, this is the expected behaviour. Either point it at _superusers with a superuser account's identity and password, or keep the least-privilege credential and build the workflow from the nodes it can reach. Test Connection states which identity you hold in its success message, so re-running it is the fastest confirmation.
A record node returns 403 or an empty list even with a valid credential
For a non-superuser credential this is API rules doing their job. Each collection has five rules and PocketBase locks all of them to superusers by default, so a newly created collection grants an ordinary account nothing until somebody writes rules for it. A locked rule means only a superuser may perform that action; an empty-string rule means anyone may, including guests; a filter expression means it depends on the record and the caller. Read the collection's current rules with PocketBase: Get Collection using a superuser credential, or open the collection in the dashboard at /_/. An empty list at HTTP 200 rather than a 403 usually means the List rule is a filter expression that excludes the rows you expected, not that the collection is empty. Relation expansion has the same shape: an expanded relation is only returned when the related collection's View rule allows it.
Nodes return 404 for paths that clearly exist in the documentation
Check the instance version before the base URL. Several nodes here call endpoints that arrived in PocketBase v0.23.0, 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, and an older server answers 404 on all of them. v0.23.0 also removed the separate /api/admins/ endpoints when admins became _superusers auth records, so a pre-0.23 instance cannot authenticate the way this integration does at all. The other cause of a 404 is a base URL pointing at something in front of PocketBase rather than at PocketBase, which Test Connection catches at its health step: it reports plainly when /api/health does not answer like a PocketBase instance.
The credential will not save because the URL is http
This is deliberate and there is no override. PocketBase has no API keys, so the credential holds a password and that password is exchanged for a token on every cold start, meaning it crosses the wire repeatedly rather than once. Over plain http it is interceptable every time. The fix is TLS in front of the instance rather than a setting: run PocketBase with a domain name so it issues a Let's Encrypt certificate, put it behind a TLS-terminating reverse proxy, or for a development instance on localhost use an https tunnel and give the credential the tunnel's hostname. If you do add a reverse proxy, set trusted-proxy handling in PocketBase: Update Settings as well, or the built-in rate limiter and the log IPs will all see the proxy's address instead of the caller's.
PocketBase: Batch Requests returns 400
The batch API is off until an operator turns it on. PocketBase documents it as a Web API that has to be explicitly enabled and configured from the dashboard under Settings > Application, and a disabled batch endpoint answers 400 rather than 404, which reads like a malformed payload. Enable it there, or with PocketBase: Update Settings by sending the batch group with enabled set true. The caps configured alongside it, on the number of sub-requests, the timeout and the body size, apply to every call afterwards, so a large batch can still be refused on a correctly enabled instance. Check the payload shape too: each sub-request takes a method and a url such as /api/collections/posts/records, plus an optional body, and an upsert is a POST whose body carries an existing id.
A filter returns 400 on every run
The filter field is an expression language, not a search term. PocketBase parses it as OPERAND OPERATOR OPERAND, so sending a bare keyword is a parser error rather than a narrowed list. Write status = "published" or created >= "2026-01-01", combine with && and ||, group with parentheses, and use ~ for like, !~ for not-like and the ? prefix for any-of matching on a multi-value field. Field names have to exist on the collection, which is what PocketBase: Get Collection answers. The same syntax applies on PocketBase: List Logs and PocketBase: Get Log Statistics, where a date window is written as part of the expression rather than as separate from and to fields.
A file download URL returns 403, or worked a moment ago and now does not
Two different causes with the same symptom. If the collection has the Protected option enabled, the URL needs a file token: set mint_token on PocketBase: Get File Download URL and the node fetches one and appends it. If a token was already on the URL, it has almost certainly expired. PocketBase documents file tokens as valid for about two minutes, which is short by design, so a URL that sat in a queue, a retry or an approval step will be dead by the time it is used. Fetch the URL in the step immediately after the node that built it. The same applies to PocketBase: Get Backup Download URL, which always mints a superuser file token because a backup download always requires one. Treat both URLs as secrets while they live: anyone holding one can read the file, and PocketBase cannot revoke it.
PocketBase: Request Password Reset succeeds but no email arrives
A 204 from that node does not mean mail was sent. PocketBase returns 204 whether or not the address exists, which is deliberate anti-enumeration behaviour, and it will also return 204 when SMTP is not configured at all. Diagnose it with PocketBase: Send Test Email instead, which sends one of PocketBase's own templates to an address you choose and returns a 400 whose body names the actual SMTP failure. Read the current mail configuration with PocketBase: Get Settings, remembering that the SMTP password comes back masked, and set it with PocketBase: Update Settings by sending the whole smtp group rather than a partial one. Check the collection too: the reset only applies to an auth-type collection, and the picker on the node shows each collection's type on its second line.
PocketBase: Restore Backup returned an error but the restore seems to have happened
Restoring restarts the running PocketBase process, so the connection this node was holding is dropped as part of normal operation. A 5xx or a transport error from that node therefore does not by itself mean the restore failed. Wait for the instance to come back and check with PocketBase: Health Check, which needs no authentication on the PocketBase side and is the right way to ask whether the server is up as distinct from whether the credential is good, then confirm the data with PocketBase: List Collections or a read against a collection you know. Remember what restoring did: the archive is a full snapshot of pb_data, so collections, records, uploaded files, settings and superusers are all now the archive's rather than yesterday's, and anything written since it was taken is gone. If the credential itself stops working afterwards, check whether the archive predates the superuser account you are connecting with.
A collection picker on a node stays empty
Every collection picker is fed by PocketBase: List Collections, so run that node on its own first. If it returns 403, the credential is not a superuser and the picker cannot populate, which is the commonest cause: the record nodes still work with a collection name typed in by hand, and the field accepts a collection id or name as free text. If it returns a transport error, the instance is unreachable rather than the picker being broken, which PocketBase: Health Check will confirm. The backup, cron job and log pickers work the same way and are fed by PocketBase: List Backups, PocketBase: List Cron Jobs and PocketBase: List Logs respectively, all four of which are superuser-only. Record ids, filenames and realtime client ids are free text by design rather than broken pickers, and each of those field descriptions names where to read the value from.
A column disappeared from a collection after an update
The fields array on PocketBase: Update Collection replaces rather than merges, so a field omitted from the payload is dropped from the table along with its stored data. This is the reason that node is classed destructive despite being an update, and there is no undo: PocketBase's only documented recovery is a backup archive taken beforehand. The pattern that avoids it is to read the current definition with PocketBase: Get Collection, edit the array it returns, and send the whole thing back. The related trap is renaming: a field keeps its data only when you keep its id and change its name, so a same-named field carrying a new id is a drop and an add rather than a rename. The indexes array behaves the same way and also replaces rather than merges.

PocketBase is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products