Menu

Mattering Automations Baserow integration

Connect Baserow to Mattering Automations: rows, fields, tables, views, webhooks, exports, snapshots, trash restore and workspace search as workflow steps, against Baserow Cloud or a Baserow you host yourself.

The Mattering Automations Baserow integration puts Baserow's REST API on your automation canvas: read and write rows one at a time or in batches, list and create fields, stand up databases and tables, build views with their filters and sorts, manage and test webhooks, start table exports, take and restore database snapshots, read and restore from the trash, and search a whole workspace. Sixty one nodes in total, twenty seven that read and thirty four that act, curated from the 410 operations Baserow documents.

The credential has two parts and the distinction runs through everything below. A Baserow database token is required: it is workspace-scoped, never expires, carries independent Create, Read, Update and Delete toggles, and reaches the row-level data plane. An account email and password are optional and unlock the schema, view, webhook, export, snapshot and workspace nodes, because Baserow serves those only to a logged-in session and publishes no long-lived scoped key for them. Sixteen of the sixty one nodes run on the token alone; the other forty five need the login as well.

One more field on that credential is worth reading before you start. Baserow is open source and self-hostable, and the base URL lives on the credential rather than in the connector, so the same nodes work against Baserow Cloud at api.baserow.io or against your own install with nothing else changed. Set it once when you create the credential in Connectors. This guide covers both, and ends with the complete node reference.

Before you start

  • A Baserow account, on Baserow Cloud or on a self-hosted install. Baserow's REST API and database tokens are part of the open source core rather than a plan feature, so there is no API tier to buy before you start.
  • A database token, created in Baserow from your workspace settings. Creating one is not a plan feature, though Baserow documents a role restriction under its Enterprise licence, where only workspace-level admins and builders can create database tokens. A token belongs to exactly one workspace, so a workflow spanning two workspaces needs two credentials.
  • A decision about the token's four permission toggles. Create, Read, Update and Delete are independent, and each can apply to every table in the workspace or only to tables you pick, so a read-only automation should hold a token that physically cannot write. An unticked box is not silent: the request comes back with an error naming the missing permission.
  • Optionally, a Baserow account email and password, if you want the schema, view, webhook, export, snapshot, trash or search nodes. This is a full account login and Baserow does not let you scope it down, so prefer a dedicated account whose workspace membership matches what the automation should reach.
  • Two-factor authentication turned off on that account. Baserow's session exchange returns a two-factor challenge instead of a session token when 2FA is on, and an automation has no way to supply an authenticator code. The same account can still hold and use a database token.
  • For a self-hosted Baserow, an https origin reachable from Mattering. Plain http is refused, because both halves of this credential are full strength and neither belongs on the wire in clear text.
  • Baserow premium, only if you intend to use Baserow: List Row Comments, Baserow: Create Row Comment, or any export format other than csv. Only the csv exporter is in Baserow's open source core, so json, xml, excel and file on Baserow: Export Table all need premium. Everything else in this integration works without it.
  • A Mattering workspace with access to the Automations app.

Create a Baserow database token

Mattering authenticates to Baserow with a database token, and optionally with an account login as well. The token is the required half and the one to get right, because it decides which workspace the connector can see and what it is allowed to do there. Creating one is not a plan feature, though Baserow does document a role restriction under its Enterprise licence, where only workspace-level admins and builders can create database tokens.

Sign in to Baserow and click your workspace name in the top left, then open Settings and go to the Database tokens tab.
Click Create token, give it a name that says which automation it is for, and choose the workspace it belongs to. A token reaches exactly one workspace, so if your workflow spans two, create two credentials.
Set the four permission toggles. Create, Read, Update and Delete are independent, and each can apply to every table in the workspace or be narrowed to specific tables. Grant only what the automation needs: a token that cannot delete is the cheapest guard against a workflow that should never have deleted anything.
Baserow states that database tokens do not expire, unlike the temporary session tokens behind the schema nodes. That makes them comfortable for unattended automations and means revocation is your off switch: deleting the token in Baserow ends the connection immediately.
Copy the token. This is the value you paste into Mattering.
If you need the schema, view, webhook, export, snapshot, trash or search nodes, decide which Baserow account will hold the connection and confirm two-factor authentication is off on it.
The optional email and password are a full Baserow account login, not a scoped key. Baserow ships no long-lived scoped key for the schema-level API, so this is the only way to reach those nodes, and the account can do everything in Baserow that a person signed in as it could do. Use a dedicated account whose workspace membership matches the automation's scope rather than an individual's personal login, and skip this half entirely if the workflow only touches rows.

Connect Baserow to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Baserow from the list, then click Create new credential.
Paste the token into Database token. This field is required.
Fill Account email (optional) and Account password (optional) only if you need the schema, view, webhook, export, snapshot, trash or search nodes. Leave them empty to run on the database token alone.
Set Base URL. Leave it at https://api.baserow.io for Baserow Cloud, or paste your own https origin with no path for a self-hosted install.
Credentials are stored encrypted in Google Secret Manager and never appear in workflow logs. The account password is exchanged for a short-lived Baserow session token at run time and refreshed automatically; the session is not stored in your automation.
Click Test Connection. Mattering calls Baserow's token check endpoint, which reads no data, and then, if you supplied them, exchanges the email and password for a session. The two halves are reported separately, so a passing token with a failing login names which one to fix.
All 61 Baserow nodes appear in your canvas palette.

Verify it works

Open any automation canvas and check the palette: a Baserow section should list the read and action nodes. Drop Baserow: List Tables for Token onto the canvas and run a test step. It is the natural first probe because it needs no other id, works on the database token alone, and returns exactly the tables the row nodes can operate on. If it comes back empty, the token is scoped to a workspace with no tables in it, or narrowed to databases and tables you did not mean.

Now pick a table id from that result and run Baserow: List Rows without changing anything else. Two things to look at in the output. The cells should be keyed by field name rather than by field_123, which is the node's user_field_names default doing its job, and the response should carry count, next and previous, which is Baserow's page and size pagination. Nothing pages automatically here, so next being populated means there is more rather than something being wrong.

If you supplied the account email and password, run Baserow: List Workspaces as well. It takes no parameters and is the top of the schema-side picker chain: workspace, then database, then table. A clear message naming the missing email or password rather than an authentication error means the token half is fine and the login half was left empty, which is a normal configuration rather than a fault. Everything in this verify path is read-only and safe to re-run whenever you want to check the connection.

Node reference

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

Read and query nodes 27

Baserow: Check Database Token

baserow_check_token

Check that the database token is valid. Baserow built this endpoint for exactly this purpose and names integrations in its own description of it, so it is the connector's zero-config probe: 200 means the token is live, 403 means it is not. It takes no parameters and reads no data. Note that this checks the DATABASE TOKEN only. It says nothing about whether the credential's optional account email and password can mint a JWT, which is what the schema, view, webhook and workspace nodes need.

Baserow: Get Export Job

baserow_get_export_job

Check an export job and collect its file URL. State moves through pending, exporting and then one of finished, cancelled, failed or expired, with progress_percentage along the way. Only read url when state is finished; it is null before that, and an expired job's file is gone. Poll this from a loop with a wait between iterations rather than hammering it, because the 10 concurrent request cap counts polls too. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Get Field

baserow_get_field

Fetch one field's definition. The properties returned depend on the field type: a single select carries its options, a link row carries the table it points at, a formula carries its expression. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Get Grid View Aggregations

baserow_get_grid_view_aggregations

Return the aggregation values configured on a grid view's footer: the sums, counts, minimums, averages and empty counts a person set up in the Baserow UI. This is the cheap way to get a number out of a big table without reading the rows. What it aggregates is whatever the VIEW is configured to aggregate, so nothing here is declarable as a measure at the connector level: the field names and the functions are chosen per view by the user. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Get Job

baserow_get_job

Check an async Baserow job: snapshot restores, duplicates, imports and template installs all return a job id rather than a finished result. The response carries state and progress_percentage, plus the created object once the job finishes. Poll it with a wait between iterations, because polls count against the 10 concurrent request cap. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Get Row

baserow_get_row

Fetch one row by id. Returns the same cell shape as List Rows, so the same user_field_names rule applies. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Get Row History

baserow_get_row_history

Read the change history of one row: who changed which cell, when, and from what to what. Useful for audit style automations and for a human readable 'what changed' summary. Paginated by limit and offset rather than page and size, which is the second of the two pagination shapes this API uses. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Get Table

baserow_get_table

Fetch one table's metadata: name, order, the database it belongs to, and its data sync configuration if it has one. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Get View

baserow_get_view

Fetch one view. The properties returned depend on the view type, and the include parameter is what pulls its filters and sorts back in the same call. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Databases

baserow_list_applications

List the applications in a workspace. In Baserow a database IS an application, and so are an Application Builder app, an automation and a dashboard, so every entry carries a type and only the ones typed database hold tables. That is why the database picker in this connector shows each entry's type on a second line. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Fields

baserow_list_fields

List a table's fields with their ids, names, types and type specific settings. Run this first whenever you are writing rows with user_field_names off, because it is where the field_123 keys come from, and it is what the field pickers elsewhere in this connector read. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: List Grid View Rows

baserow_list_grid_view_rows

Read rows through a grid view, with the view's own filters and sorts already applied. Two things this offers that Baserow: List Rows does not: it accepts limit and offset as well as page and size, which is the second pagination shape in this API, and it can return field_options so a consumer knows the view's column widths and hidden columns. Note it has no user_field_names parameter, so cells always come back keyed field_123 here. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List MCP Endpoints

baserow_list_mcp_endpoints

List the account's Baserow MCP endpoints. Baserow ships a native Model Context Protocol server, hosted by Baserow itself, and these are the per-workspace endpoints that front it. CAUTION: each entry includes its key, and Baserow's own words are to treat the MCP URL like a password because it can modify data. Anything downstream of this node receives a live credential, so do not log it, post it to a chat channel, or write it into a record. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Row Comments

baserow_list_row_comments

List the comments on a row. This is a Baserow PREMIUM feature: on a plan without premium the endpoint returns an error rather than an empty list, which is a legitimate result and not a broken connection. Paginated by limit and offset or by page and size. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Row Names

baserow_list_row_names

Resolve row ids to their display names, which in Baserow means the primary field value of each row. Built for showing what a link row cell actually points at without fetching whole rows from the linked table. The parameter name contains a literal brace (table__{id}), so it is supplied through Extra query parameters: a key of table__512 with a value of 1,2,3 asks for those three rows in table 512, and several tables can be asked for at once. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: List Rows

baserow_list_rows

List rows from a table, paginated by page and size. This is the connector's main read. Cells come back keyed by field name by default; turn user_field_names off to get field_123 keys instead. Filtering has two mechanisms that must not be mixed: the filters tree, a JSON structure this node takes as a field, and the scalar filter__field__type family, whose parameter names contain braces and so live in Extra query parameters. Pointing view_id at an existing view reuses that view's filters and sorts, which is usually less work than rebuilding them here. Nothing pages automatically: the response carries count, next and previous, and the loop belongs in the automation. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: List Snapshots

baserow_list_snapshots

List the snapshots taken of a database, with when each was created and by whom. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Tables for Token

baserow_list_token_tables

List every table the database token can reach, with its id, name and containing database id. This is the discovery root for the whole connector: it needs no other id, it works with the token alone, and it lists exactly the tables the row nodes can operate on, which is why every table picker in this connector reads from it. Baserow only serves this endpoint to a database token, so a JWT will not work here even though a JWT reaches almost everything else.

Baserow: List Tables in Database

baserow_list_tables

List the tables inside one database. The JWT counterpart to List Tables for Token: it is scoped by database rather than by token permissions, so it sees tables a database token may not be allowed to touch. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Trash Contents

baserow_list_trash_contents

List what is currently in a workspace's trash: deleted rows, fields, tables, views and databases, each with the trash_item_id and trash_item_type that Baserow: Restore Trash Item needs. Read this before restoring rather than guessing an id. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Unique Field Values

baserow_list_field_unique_values

List the distinct values present in one field, without pulling the rows. Useful for building a picker, for checking what a free text column has drifted into, and for branching an automation on the set of values rather than on one row. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List View Filters

baserow_list_view_filters

List the filters attached to a view, each with the field it applies to, the comparison type and the value. Read this before changing a view's filters from an automation, so you know which filter ids you are about to replace. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List View Sortings

baserow_list_view_sortings

List the sorts attached to a view, each with its field, direction and priority. Priority is what decides which sort wins when two disagree. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Views

baserow_list_views

List a table's views with their ids, names and types. This is where the view pickers in this connector read from, and it is the practical way to reuse a filter someone already built in the Baserow UI: find the view here, then pass its id to Baserow: List Rows. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Webhooks

baserow_list_webhooks

List the webhooks configured on a table, with their URLs, events, active state and recent call results. The call history is the useful part when a downstream automation stopped firing and nobody knows whether Baserow stopped sending or the receiver stopped answering. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: List Workspaces

baserow_list_workspaces

List every workspace the account belongs to, with the account's permission level in each. This is the top of the JWT side of the picker chain: workspace, then database, then table. It needs no parameters. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Search Workspace

baserow_search_workspace

Search across everything in a workspace: applications, tables, views and rows. Use it when an automation has a human's phrasing rather than an id, and needs to find what they meant. The response carries a has_more flag so a caller can tell a truncated result from a complete one. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Action nodes 34

Baserow: API Request

baserow_api_request

Call any Baserow API endpoint that this connector does not ship as its own node. Baserow publishes 410 operations and this connector ships 60 of them as nodes, so this is the escape hatch for the other 350: admin endpoints, the Application Builder, teams and role assignments, data syncs, the AI surfaces, and anything Baserow adds after this connector was written. Authentication, the base URL and the concurrency limit are handled for you; the method, path and body are yours. Flagged destructive because the method and path are free text, so this node is exactly as dangerous as whatever you point it at, and nothing here can tell a read from a delete before it runs.

Baserow: Create Database

baserow_create_application

Create a database in a workspace. Type defaults to database, which is the only application type whose tables this connector operates on. Init with data asks Baserow to seed it with a starter table rather than leaving it empty. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create Field

baserow_create_field

Add a field to a table. Every field type takes name and type, and most take extra type specific settings which go in Extra body fields: select options for a single select, link_row_table_id for a link row, a formula string for a formula. Baserow documents 29 field types and models each one separately, so the shared fields are typed here and the type specific half is passed through rather than guessed at. Creating a field can change other fields, and Baserow returns those in a related_fields key. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Create MCP Endpoint

baserow_create_mcp_endpoint

Create a Baserow MCP endpoint for a workspace, so an LLM client can act in that workspace through Baserow's own native MCP server. The response carries the key, which is the secret half of the URL you paste into the client, so the same caution applies as on the listing node: this output is a credential. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create Row

baserow_create_row

Create one row. The body IS the cell map, so Fields takes an object like {"Name": "Acme Corp", "Status": "Active"} when user_field_names is on, or {"field_1": "Acme Corp"} when it is off. Any field you leave out gets its default or null. There is no idempotency key on this API, so a retried run creates a second row: dedupe on your side if the trigger can fire twice. Reversible from an automation with Baserow: Delete Row. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Create Row Comment

baserow_create_row_comment

Post a comment on a row. Useful for leaving an audit trail where a human will actually see it, next to the record, rather than in a run log. A Baserow PREMIUM feature, so it errors on a plan without premium. The comment is attributed to the account whose email and password are on the credential, not to the person who triggered the automation. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create Rows in Batch

baserow_batch_create_rows

Create many rows in one request. Items is an array of cell maps, each shaped exactly like the Fields object on Create Row. This is the right node for any sync loop: one request for a hundred rows instead of a hundred requests against a 10 concurrent request cap. The whole batch succeeds or fails together, and there is still no idempotency key, so a retry duplicates the entire batch. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Create Snapshot

baserow_create_snapshot

Take a point-in-time snapshot of a whole database. This is the node to put in front of anything destructive in an unattended automation: a bulk import, a field type change, a mass delete. Snapshots count against plan limits on Cloud, so a workflow that takes one on every run will hit a ceiling. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create Table

baserow_create_table

Create a table in a database, optionally seeded with rows. Leave Data empty and you get an empty table with Baserow's default fields. Fill Data with an array of arrays and Baserow imports it, using the first row as the header when First row header is on, which is the quickest way to turn an upstream node's tabular output into a real table. This is the synchronous variant; Baserow also publishes an async one for large imports, which this connector does not ship because it returns a job id rather than a table. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create View

baserow_create_view

Create a view on a table. Every type takes name and type; the type specific settings go in Extra body fields, because Baserow models each view type separately (a kanban needs the single select field it groups by, a calendar needs its date field). Reversible with Baserow: Delete View, and a view holds no data of its own. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create View Filter

baserow_create_view_filter

Add a filter to a view. Filters attached to a view apply to everything reading through that view, including Baserow: List Rows when you pass its view id, so this is how an automation narrows a shared view rather than repeating filter logic in every node. Reversible with Baserow: Delete View Filter. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create View Sort

baserow_create_view_sort

Add a sort to a view. Rows read through the view come back in this order, so it is the cheapest way to make Baserow: List Rows deterministic without an order_by on every call. Reversible with Baserow: Delete View Sort. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Create Webhook

baserow_create_webhook

Create a webhook on a table, so Baserow calls a URL when rows, fields or views change. Two things to know. Baserow's batch row delete does not fire rows.deleted, so a webhook listening for it will miss anything removed through Baserow: Delete Rows in Batch. And use_user_field_names controls whether the payload is keyed by field name or by field_123, which is the same choice, and the same trap, as user_field_names on the row nodes. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Delete Database

baserow_delete_application

Delete an entire database: every table, field, view, webhook and row inside it. DESTRUCTIVE, and the widest blast radius of any node in this connector. It goes to Baserow's trash and Baserow: Restore Trash Item can bring it back inside the retention window, which Baserow documents as 3 days on Baserow Cloud and which a self-hosted install sets for itself, so this is recoverable in the same sense a recycle bin is. Consider Baserow: Create Snapshot first if the automation is unattended. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Delete Field

baserow_delete_field

Delete a field and every value in it, across every row. DESTRUCTIVE. Baserow refuses to delete a primary field, because its value is what identifies a row, and deleting a field can change others (a lookup pointing at it, for instance) which come back in related_fields. The field goes to trash and is restorable through Baserow: Restore Trash Item within the retention window. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Delete Row

baserow_delete_row

Delete one row. DESTRUCTIVE. The row goes to Baserow's trash rather than disappearing outright, so Baserow: Restore Trash Item can bring it back while it is still within the retention window, which Baserow documents as 3 days on Baserow Cloud and which a self-hosted install sets for itself. Treat that as a recovery path, not a safety net. Returns 204 with no body. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Delete Rows in Batch

baserow_batch_delete_rows

Delete many rows in one request. DESTRUCTIVE, and note the method: this is a POST that deletes, on its own batch-delete path, because Baserow needs a body to carry the row ids. Two things to know before wiring it up. Baserow's own documentation says this endpoint does not yet fire row deleted webhooks, so anything listening for rows.deleted will not see these removals and will look broken rather than un-notified. And the rows go to trash, recoverable through Baserow: Restore Trash Item while the retention window lasts. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Delete Table

baserow_delete_table

Delete a table and every row, field and view in it. DESTRUCTIVE, and the second widest blast radius in this connector after Delete Database. Nothing about the config for this node distinguishes a test table from a production one, so put a condition in front of it rather than wiring it straight off a trigger. The table goes to Baserow's trash and Baserow: Restore Trash Item can bring it back inside the retention window, which Baserow documents as 3 days on Baserow Cloud and which a self-hosted install sets for itself, so do not treat it as an undo you can rely on. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Delete View

baserow_delete_view

Delete a view, along with its filters, sorts and display settings. DESTRUCTIVE but narrow: the ROWS are owned by the table, not the view, so no data is lost. What is lost is the configuration someone built, plus any public share link pointing at it, which stops working immediately. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Delete View Filter

baserow_delete_view_filter

Remove a filter from a view. DESTRUCTIVE in a way that is easy to underestimate: no rows are deleted, but the view immediately starts showing rows it was hiding, and anything reading through that view, including a public share link, sees them too. Narrow the blast radius by reading Baserow: List View Filters first rather than deleting by a remembered id. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Delete View Sort

baserow_delete_view_sort

Remove a sort from a view. DESTRUCTIVE only of the sort itself: no rows change, but anything that relied on the view's ordering, including a paged read, starts coming back in a different order. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Delete Webhook

baserow_delete_webhook

Delete a webhook. DESTRUCTIVE of the integration rather than of data: no rows change, but whatever was listening stops receiving, silently, with nothing on the receiving side to indicate why. Prefer setting active to false with Baserow: Update Webhook when you only want to pause it. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Export Table

baserow_export_table

Start an export of a table or of one of its views. This returns a JOB, not a file: the response carries an id and a state of pending, and the download URL only appears once the state reaches finished. Poll it with Baserow: Get Export Job. Formats are csv, json, xml, excel and file. Exporter specific options, such as the csv separator, go in Extra body fields because Baserow models each exporter separately. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Move Row

baserow_move_row

Move a row to a different position in the table. With before_id set the row lands immediately before that row; leave it empty and the row moves to the end. Only the row's order changes, never its cells. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Restore Snapshot

baserow_restore_snapshot

Restore a snapshot. Baserow restores it as a NEW database alongside the existing one rather than overwriting it, so nothing is lost by running this, and the cleanup afterwards is a human decision about which copy to keep. It is an async job: the response carries a job id to poll with Baserow: Get Job. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Restore Trash Item

baserow_restore_trash_item

Restore something out of the trash: a row, field, table, view or whole database. This is the undo behind every destructive node in this connector, and it works only inside Baserow's retention window, which Baserow documents as 3 days on Baserow Cloud and which a self-hosted install sets for itself. Some types need the parent's id as well, because a row is identified by its table: restoring a row means trash_item_type row, trash_item_id the row id, and parent_trash_item_id the table id. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Test Webhook Call

baserow_test_webhook

Send a test call to a webhook URL and get back the exact request Baserow sent and the response it received. This is the debugging node: it answers whether the receiver is reachable, what it returned and how long it took, without creating a webhook or touching any rows. It does send a real HTTP request to the URL, so point it at a receiver you own. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Update Field

baserow_update_field

Change a field's name, type or settings. Flagged DESTRUCTIVE even though it deletes nothing, because CHANGING THE TYPE CONVERTS EVERY CELL and Baserow's own warning is that a value which cannot be converted is set to null. Turning a text column into a number silently empties every cell that was not a number, across the whole table, with no per-cell report. Renaming is safe. If you only want to rename, send name and leave type empty. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Update Row

baserow_update_row

Update the cells of one row. A PATCH, so only the fields you send change and everything else is left alone. Keys follow user_field_names exactly as on Create Row, and the same key check runs before the request leaves, because an unrecognised key here is the silent no-op this API is known for. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Update Rows in Batch

baserow_batch_update_rows

Update many rows in one request. Each entry in Items must carry an id plus the cells to change, and every other cell on those rows is left alone. Same path as Create Rows in Batch but a PATCH rather than a POST, which is the whole difference between adding and amending here. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Baserow: Update Table

baserow_update_table

Rename a table. Renaming does not change the table id, so anything referencing the table by id keeps working. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Update View

baserow_update_view

Update a view's name, filter behaviour or public sharing. The type cannot be changed after creation. Setting public to true publishes a share link for the view, which is a disclosure decision rather than a formatting one: anyone with the link sees the rows the view shows, without logging in. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Update Webhook

baserow_update_webhook

Update a webhook. The field that earns this node its place is active: Baserow deactivates a webhook automatically after repeated failures, and this is how an automation turns it back on once the receiver is healthy, or turns it off before a bulk import that would otherwise stampede it. Needs the Baserow credential's account email and password, because this endpoint is not reachable with a database token.

Baserow: Upload File From URL

baserow_upload_file_via_url

Have Baserow fetch a file from a public URL and store it as a user file. This is step one of putting a file in a file cell: the response's name is what you then write into the cell, as [{"name": "<returned name>"}], with Baserow: Update Row. Baserow's other upload endpoint takes raw multipart bytes and is not shipped here, because this layer has no file-source primitive to feed it. Works with the database token. The token's workspace scope and its Create, Read, Update and Delete toggles both apply, so a token missing the right toggle returns 401 with an error naming the permission rather than an empty result.

Using the integration

Two credentials in one, and which nodes need which

Baserow's API has two authentication systems, and this integration carries both on one credential because neither alone makes a useful connector. The database token reaches the data plane: Baserow: List Rows, Baserow: Get Row, Baserow: Create Row, Baserow: Update Row, Baserow: Delete Row, Baserow: Move Row, the three batch nodes, Baserow: List Row Names, Baserow: List Fields, Baserow: Create Field, Baserow: Upload File From URL, Baserow: List Tables for Token and Baserow: Check Database Token. That is sixteen nodes counting Baserow: API Request, which accepts either. Everything else, forty five nodes covering workspaces, databases, tables, views, filters, sorts, webhooks, exports, snapshots, trash, search, row history, row comments and grid view aggregations, is served by Baserow only to a logged-in session, so it needs the optional email and password. Baserow is explicit about that ceiling: a database token only reads and manipulates the data of a table, and structural changes need a session token instead. One naming trap while you are looking for a way around it. Baserow's own documentation uses the phrase personal API tokens as a synonym for database tokens, so a page with that title is not a second, JWT-capable credential; there is no scoped key for the schema-level API at all. Two of the sixteen go the other way and are token-only: Baserow does not serve Baserow: List Tables for Token or Baserow: Check Database Token to a session at all. That is why the token is the required half. Because it is always present, every table picker in this integration reads from the token's own table lister and populates for every credential rather than only for the ones that also carry a login. The trade is that it lists only the token's workspace, so a user with several workspaces pastes a table id instead, which the field accepts.

Baserow Cloud or your own install

Baserow is open source and self-hostable, and this integration treats both as the same connector. Base URL on the credential decides which one you are talking to: leave it at https://api.baserow.io for Baserow Cloud, or paste your own origin for a self-hosted install. Nothing else changes. The same 61 nodes, the same database token, the same optional account login, the same pickers. Two things differ in a self-hosted install's favour. There is no concurrency cap by default, because Baserow states that a self-hosted install will never place limits on rows, records, webhooks or API requests; a concurrency throttle does exist as an option in Baserow's own configuration and ships disabled, so if you are self-hosting and seeing throttling, that setting is where to look. And the trash retention window is yours rather than a property of a plan, so how long Baserow: Restore Trash Item can still undo something is a configuration decision rather than the 3 days Baserow documents on Cloud. One constraint: the origin must be https and must have no path on it. Plain http is refused rather than downgraded, because a database token and an account password are both full-strength credentials.

user_field_names, and the write that returns 200 and does nothing

This is the most expensive thing to learn about Baserow's API the hard way, and the integration is built to keep you out of it. Baserow keys row cells by field id, as field_123, unless the user_field_names parameter is set, in which case they are keyed by the field's name. The trap is that this is a query parameter that also governs the shape of POST and PATCH request bodies. Read rows with names on, feed them into a write with the parameter off, and Baserow accepts the request, answers 200, and changes nothing, because every key in the body was an unrecognised name. No error, no warning, and a run log that looks like a success. Two mitigations are built in. Every row node defaults user_field_names to on, read and write alike, so the asymmetry the trap needs is not there by default. And when the flag is off, the connector checks the payload's keys before the request leaves and returns an error naming the offending ones rather than letting the write succeed emptily. If you do work with ids, run Baserow: List Fields first, since that is where the field_123 keys come from. Neither choice is free: field ids are not portable between workspaces, so a workflow copied to another workspace breaks silently on ids, while field names break loudly when someone renames a column. Names fail in the direction you can see, which is why they are the default.

Rows in batches, and the concurrency cap that makes it matter

Baserow Cloud publishes a limit of 10 concurrent API requests under a fair use policy, and reserves the right to lower it. That is a concurrency cap, not a per-minute quota, and Baserow publishes no requests-per-minute number anywhere, so there is no budget to pace against in the usual sense. What it does mean is that request count is worth minimising. Baserow: Create Rows in Batch and Baserow: Update Rows in Batch each write many rows in a single call, where a per-row loop spends the concurrency budget on overhead; Baserow: Delete Rows in Batch does the same for removals. Nothing in this integration auto-paginates, which is deliberate: the response carries count, next and previous, and the loop belongs on the canvas where its cost is visible rather than hidden inside one step. Pagination has two shapes in this API rather than one, so each node states the one its endpoint actually takes: page and size on Baserow: List Rows and most collections, limit and offset on Baserow: List Grid View Rows, Baserow: Get Row History and Baserow: List Row Comments. And where a node polls, such as Baserow: Get Export Job or Baserow: Get Job, put a wait between iterations, because polls count against the cap too.

Filtering, and the two mechanisms that must not be mixed

There are two ways to filter a row read and they are not interchangeable. The first is the filters tree, a JSON structure this integration takes as a field on Baserow: List Rows, which is the readable option and the one to reach for. The second is Baserow's scalar family, whose parameter names contain the field in the name itself, as in filter__field_1__equal. Those are not valid configuration keys, so they travel through the node's extra query parameters field, whose keys go on the wire verbatim. Two other families work the same way: the link row lookup family, and the table__{id} form on Baserow: List Row Names, where the extra query parameters field is the whole parameter set and therefore required. Baserow documents that filter_type is ignored when filters is present, and says nothing at all about combining filters with the scalar family, so that combination is undefined. This integration refuses a request that sets both rather than guessing which one Baserow honours, because the two failure modes are an error you can read and a silently wrong row set. The usually better option than either is to point Baserow: List Rows at a view id: the view's own filters and sorts apply, which reuses something a person already built in the Baserow interface instead of restating it in the workflow.

Building structure, not just filling it

Most spreadsheet-database integrations stop at rows. This one can create the container. Baserow: Create Database and Baserow: Create Table stand up a database and a table, and Create Table accepts an array of arrays with an optional header row, so an upstream node's tabular output becomes a real table in one step. Baserow: Create Field adds columns: name and type are typed fields and the type-specific half goes through the extra body fields, because Baserow documents 29 field types and models each separately, so a select option list, a link row target or a formula expression goes there rather than being guessed at. Baserow: Create View, Baserow: Create View Filter and Baserow: Create View Sort build the saved view a team will actually use, and a filter added to a shared view applies to everything reading through it, including Baserow: List Rows when you pass its view id. One warning about naming: in Baserow a database IS an application, and so is an Application Builder app, an automation and a dashboard, so Baserow: List Databases returns all four types and only the ones typed database hold tables. The picker shows each entry's type for exactly that reason.

Deletes, the trash, and the one node that destroys without deleting

Eleven nodes carry a destructive flag and they are genuinely different from each other. Most send the object to Baserow's trash, so Baserow: List Trash Contents and Baserow: Restore Trash Item are a real undo for a row, a field, a table, a view or an entire database, inside the retention window, which Baserow documents as 3 days on Cloud and which a self-hosted install sets for itself with the HOURS_UNTIL_TRASH_PERMANENTLY_DELETED setting. Treat that as a recovery path rather than a safety net, and put Baserow: Create Snapshot in front of anything unattended, since Baserow: Restore Snapshot brings a database back as a new one alongside the original rather than overwriting it. Three deserve individual attention. Baserow: Update Field deletes nothing and is the sharpest node here, because changing a field's type converts every cell in the column and Baserow's own warning is that a value which cannot be converted is set to null, across the whole table, with no per-cell report; leave the type empty if you only meant to rename. Baserow: Delete View Filter removes no rows at all and is a disclosure event, because the view immediately starts showing rows it was hiding and anything reading through it, including a public share link, sees them. And Baserow: Delete Webhook destroys an integration silently: nothing on the receiving side shows why it stopped, so prefer setting active to false with Baserow: Update Webhook when you only want to pause it.

Webhooks, exports and the async jobs behind them

Baserow: Create Webhook, Baserow: Update Webhook, Baserow: Delete Webhook and Baserow: List Webhooks manage a table's webhooks from a workflow, so a deployment can wire its own delivery rather than someone doing it by hand. Baserow: Test Webhook Call is the one that earns the family its place: it sends a real test request and returns the exact request Baserow sent and the response it received, which turns a guess into an answer. It does send a real HTTP request, so point it at a receiver you own. Two behaviours to design around. Baserow deactivates a webhook automatically after repeated failures, which is what the active field on Baserow: Update Webhook is for, and Baserow's own note on its batch row delete is that the endpoint does not yet work with row deleted webhooks, so anything listening for that event will miss removals made with Baserow: Delete Rows in Batch and will look broken rather than un-notified. Exports work the same asynchronous way: Baserow: Export Table returns a job with a state of pending rather than a file, and Baserow: Get Export Job is the poll that collects the download URL once the state reaches finished, with the url field null before then and gone once the job expires. Baserow: Get Job covers the other async operations, including snapshot restores.

Baserow's own MCP server, and provisioning it from a workflow

Baserow ships a native, built-in MCP server. You create an MCP endpoint, Baserow returns a URL with a secret in it, and you paste that into an MCP client. If what you want is a chat window that can read and write your rows, that is the shortest route and it is a good one. This integration is a different shape: its nodes are canvas steps as well as MCP tools, so the same capability runs unattended on a schedule with nobody in the chat window, chains with every other connector in one workflow, holds the credential once in a shared workspace store rather than in each person's local client config, and flags the destructive nodes so a workflow can gate on them. Every node here also 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 61 nodes. The two compose rather than compete: Baserow: List MCP Endpoints and Baserow: Create MCP Endpoint let an automation provision Baserow's own endpoints. Handle that output carefully. It contains the endpoint key, Baserow's own advice is to treat the MCP URL like a password, and anything downstream of those nodes is receiving a live credential, so do not log it, post it to a chat channel or write it into a record.

On the automation canvas, and from AI assistants

Baserow nodes chain with every other node in Mattering. An inbound webhook, a form submission or a scheduled read from another connector can land in a Baserow table with Baserow: Create Rows in Batch; a status change in Baserow can become a Slack message, an invoice or a Mattering Productivity task; Baserow: Get Grid View Aggregations can turn a view's footer into a number for a daily digest without reading a single row. Baserow: Search Workspace is the node for the case where an automation has a human's phrasing rather than an id. When an assistant is driving, the sensible split is to hand it the 27 read nodes and put the writes behind a condition or an approval step, especially the eleven flagged destructive: an agent reading rows and history to summarise what changed is low risk, and an agent holding Baserow: Delete Table is not. One thing no workflow gets for free: Baserow documents no idempotency mechanism on any write, so a retried Baserow: Create Row is a second row and a retried Baserow: Create Rows in Batch is a duplicated batch. Dedupe on your side, or read before you write.

Troubleshooting

A request returns 404 and the URL looks correct
Check the trailing slash first. Baserow's API requires one on every path and does not redirect, so a URL that looks right does not route. The 404 body is explicit about it, carrying an error of URL_TRAILING_SLASH_MISSING and a detail naming the URL you should have called, so read the body before assuming the path is wrong. Every path shipped in this integration ends in a slash and the module asserts it at import time, so this can only reach you through Baserow: API Request, the passthrough node, where you type the path yourself. That node re-adds a missing trailing slash before the query string rather than letting the call fail, so a genuine 404 there is usually the second cause instead: an id from the wrong place. A table id from a workspace your database token does not cover comes back as not found rather than as a permission error, so confirm the id against Baserow: List Tables for Token.
Test Connection fails, or a node returns 403 with ERROR_TOKEN_DOES_NOT_EXIST
That specific error is Baserow saying the database token itself is not recognised, and it arrives as a 403 rather than the 401 people expect. Three causes in order. The token was deleted or regenerated in Baserow, in which case paste the current value. The token was copied with surrounding whitespace or only partially. Or the base URL points at a different Baserow from the one the token belongs to, which is the common one for self-hosted installs, since a Cloud token means nothing to your own server and the other way round. Test Connection reports the token half and the account login half separately, so read which half failed before changing anything.
A node returns 401 naming a permission
This is the database token's permission toggles rather than a bad credential. Create, Read, Update and Delete are independent on a Baserow token and each can be narrowed further to particular tables, so a token issued for a read-only automation returns exactly this when a workflow later tries to write. Baserow names the missing permission in the error rather than returning an empty result, which is the useful behaviour here. Open the token from your workspace settings, on the Database tokens tab, tick what the automation now needs, and re-run. If you would rather the automation could not do it at all, that is the correct answer already and the workflow is the thing to change.
A schema, view, webhook, export or workspace node says the credential is missing an email and password
It is a configuration message rather than a failure, and it means the connector stopped before sending. Baserow serves those endpoints only to a logged-in session and publishes no long-lived scoped key for them, so forty five of the sixty one nodes need the optional account email and password on the credential. Sixteen do not: every row read and write, the batch nodes, Baserow: List Fields, Baserow: Create Field, Baserow: Upload File From URL, Baserow: List Tables for Token, Baserow: Check Database Token and Baserow: API Request. Edit the credential in Connectors and add the login, or rebuild the workflow on the token-only nodes if you would rather not store an account password.
The account email and password are correct and the session still will not start
Two-factor authentication on that Baserow account is the usual cause. Baserow answers the session exchange with a two-factor challenge instead of a session token, and finishing it needs a code from an authenticator that an automation cannot supply, so a completely correct password fails in a way that reads like a wrong one. The connector detects that response shape and names it rather than reporting an authentication failure. Use a Baserow account without 2FA for the connection, ideally a dedicated one whose workspace membership matches the automation's scope. That account can still hold and use a database token if you would rather keep 2FA on your own login.
A write returned 200 but nothing changed in the table
This is Baserow's user_field_names behaviour. Row cells are keyed field_123 by default and by field name when the parameter is set, and it is a query parameter that also governs the shape of POST and PATCH bodies, so a body keyed one way and a request flagged the other is accepted, answered 200, and applied to nothing. Every row node here defaults the parameter to on for reads and writes alike so the mismatch does not arise, and when it is off the connector checks the payload's keys before sending and returns an error naming the offending ones. If you see this, the most likely cause is a body assembled by hand or from a template rather than from a preceding Baserow read. Check that the flag and the keys agree, and run Baserow: List Fields if you need the field_123 names.
A row read returns the wrong rows, or an error about mixed filters
Baserow has two filtering mechanisms and mixing them is undefined. The filters tree is a JSON structure and the readable option. The scalar family, filter__field_1__equal and its relatives, has the field in the parameter name, so it travels through the node's extra query parameters where keys go on the wire verbatim. Baserow documents that filter_type is ignored when filters is present and documents nothing at all about combining filters with the scalar family, so this integration refuses a request that sets both rather than guessing. Set one or the other. If neither is behaving, check whether the node also has a view id, because a view applies its own filters and sorts on top of anything you pass. Reusing a view is usually the better answer than either mechanism.
An export job never produces a file, or the download URL is empty
Baserow: Export Table returns a job, not a file. The response carries an id and a state of pending, and the url field stays null until the state reaches finished, so a workflow that reads url straight from the export call always gets nothing. Poll with Baserow: Get Export Job and read the URL only when the state is finished, putting a wait between iterations because polls count against Baserow Cloud's 10 concurrent request cap. The other states are worth branching on: cancelled and failed mean it will never finish, and expired means the file existed and is gone. One plan cause worth ruling out: only the csv exporter is in Baserow's open source core, so json, xml, excel and file all require premium and error on a plan without it.
A node returns an error mentioning premium, or row comments do not work
Some Baserow features are premium and the endpoint answers with an error rather than an empty result, which is a legitimate response and not a broken connection. In this integration that is exactly three places: Baserow: List Row Comments, Baserow: Create Row Comment, and every export format except csv, since only the csv exporter is in Baserow's open source core and json, xml, excel and file are all premium. Everything else works on the core. If you want the same behaviour without premium, write the note into a long-text field with Baserow: Update Row instead of posting a comment, and export as csv. Note also that a comment is attributed to the Baserow account on the credential rather than to whoever triggered the automation, so name that account something a colleague will recognise before you rely on comments as a record.
A downstream automation stopped receiving Baserow webhook calls
Start with Baserow: List Webhooks, which returns each webhook's active state and its recent call results, so you can tell whether Baserow stopped sending or the receiver stopped answering. Baserow deactivates a webhook automatically after repeated failures, and Baserow: Update Webhook with active set to true turns it back on once the receiver is healthy. If the webhook looks active and healthy but specific events are missing, check whether the removals came from Baserow: Delete Rows in Batch: Baserow's own note on its batch delete is that the endpoint does not yet work with row deleted webhooks, so those rows disappear without a notification and the listener looks broken rather than un-notified. Baserow: Test Webhook Call sends a real request and returns both the request Baserow sent and the response it received, which settles reachability without waiting for a real event.
A picker on a node stays empty
Start with what the picker reads from. The table pickers all read from Baserow: List Tables for Token, so run that on its own first: an empty result means the token is scoped to a workspace with no tables, or narrowed to databases and tables you did not intend, and no table picker will populate either. Because that lister covers only the token's workspace, a user with several workspaces will not see the others in the picker, and the field accepts a pasted table id for exactly that case. The schema-side pickers, workspace then database then view then field then webhook, all need the optional account email and password, so an empty one there usually means the credential has only its token half. And several pickers are scoped by a parent field: views and fields narrow to a chosen table, filters and sorts to a chosen view, and snapshots to a chosen database, so set the parent first.
Requests slow down or fail during a large sync
Baserow Cloud publishes a limit of 10 concurrent API requests under a fair use policy and reserves the right to lower it. There is no per-minute quota to pace against, so the fix is shape rather than timing. Replace per-row writes with Baserow: Create Rows in Batch and Baserow: Update Rows in Batch, which write many rows in a single request, and use Baserow: Delete Rows in Batch for removals. Add a wait between iterations wherever a workflow polls, since Baserow: Get Export Job and Baserow: Get Job consume the same budget. Nothing here auto-paginates, so if a run is making far more requests than you expected, the loop is on the canvas and visible. A self-hosted Baserow does not have the cap: Baserow states that a self-hosted install will never place limits on rows, records, webhooks or API requests, and the optional concurrency throttle in its own configuration ships disabled.

Baserow 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