Menu
Mattering Automations connector

A Baserow MCP that points at Baserow Cloud or your own server

61 nodes across rows, fields, tables, views, view filters and sorts, webhooks, exports, snapshots, trash restore and workspace search, curated from the 410 operations Baserow documents. The base URL is part of the credential, so the same nodes work against api.baserow.io or a Baserow you host yourself. Row reads and writes are batch first, and every destructive node says what it destroys and whether the trash can bring it back.

61 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Baserow MCP connector does

The Baserow connector for Mattering Automations is 61 nodes built from Baserow's own OpenAPI document rather than from a summary of its reference page. Rows are the core: list, get, create, update, delete, move, and the three batch endpoints that turn a hundred writes into one request. Around that sit the schema objects an automation needs in order to find anything: workspaces, databases, tables, fields, views, view filters and view sortings. Then the operational surfaces, which are the ones people are surprised to find in a connector at all: webhooks including the test call, table exports and their job poll, database snapshots, trash listing and restore, workspace search, row history, row comments and grid view aggregations. Twenty seven nodes read and thirty four act.

Every capability is a node on the Automations canvas, and every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and any MCP-capable assistant can connect to your workspace and work with Baserow through them, alongside Matter, the AI assistant built into the platform. The same nodes are canvas steps, so the thing an agent helps you design can then run on a schedule with nobody watching it.

Baserow ships a native, built-in MCP server of its own, and this page is not going to pretend otherwise. You create an MCP endpoint in Baserow, get a URL with a secret in it, and paste that into an MCP client. If what you want is a chat window that can read and write your Baserow rows, that is the shortest path and you should use it. The argument for this connector is a different one. These nodes run unattended on a schedule or a trigger with nobody present, chain with every other connector in the same workflow so a Baserow row can become a Slack message, an invoice or a task in another system, hold the credential once in a shared workspace store rather than in each person's local client config, and carry destructive flags that a workflow can gate on. This connector also goes the other way: Baserow: List MCP Endpoints and Baserow: Create MCP Endpoint let an automation provision Baserow's own MCP endpoints, which is useful and also a disclosure risk, because the response contains the key. Baserow's own advice is to treat that URL like a password, and both node descriptions say so.

Baserow is open source and self-hostable, and this connector treats that as a first-class case rather than a footnote. Baserow describes itself as open core: the non-premium and non-enterprise code, which includes the REST API and database tokens, is under the MIT licence, and the premium and enterprise features sit on top of it. The base URL is a field on the credential, so the same 61 nodes work against Baserow Cloud at api.baserow.io or against a Baserow you run yourself, with no separate connector and no code change. Plain http origins are refused, because the credential is full strength and does not belong on the wire in clear text. That matters more than it sounds: a team that keeps its operational data on its own infrastructure usually cannot use a hosted-only integration at all, and it is the main structural difference between Baserow and the closed spreadsheet-database products this connector sits next to in the palette.

The credential carries two authentication modes because Baserow's API genuinely has two, and neither one alone makes a useful connector. A Baserow database token is required. It never expires, is scoped to a single workspace, and carries its own Create, Read, Update and Delete toggles, and it reaches the row-level data plane: sixteen of the sixty one nodes run on it alone, including every row read and write, the batch endpoints, field listing and creation, and the URL file upload. An account email and password are optional, and unlock the other forty five, because Baserow serves the schema, view, webhook, export, snapshot and workspace surfaces only to a logged-in session and ships no long-lived scoped key for that half of the API. Requiring the scoped, revocable credential and making the unscoped one opt-in is the honest ordering, and it also fixes a real problem: because the token is always present, every table picker in the connector can source from the token's own table lister and populate for every credential.

Sixty one nodes out of 410 documented operations is a curation, so here is what is not in it. Baserow's Application Builder, its own automation engine and its dashboard product all share the same API and are all excluded, because building Baserow automations from inside an automation product is not a thing anyone reaches for. So are instance and account administration, the user and authentication endpoints, AI provider configuration, the AI assistant, teams, role assignments and field permissions, the audit log, workspace invitations, the notification inbox, and the anonymous public-share endpoints, which take a share slug rather than a credential and would be misrepresented behind a credentialed node. Nothing is unreachable, though: Baserow: API Request is an advanced node that calls any Baserow API endpoint, with authentication, the base URL and the concurrency limit handled and the method, path and body left to you. It is flagged destructive precisely because nothing can tell a read from a delete before it runs.

Two details about this API will read as a broken connector when they are nothing of the sort, so they are worth knowing before you build. First, trailing slashes are mandatory. A request to a Baserow API path without its trailing slash returns 404 with no redirect, so a URL that looks correct simply is not. Every path in this connector ends in a slash, the module asserts it at import time, and the passthrough node re-adds a missing one before sending. Second, Baserow Cloud's published limit is a concurrency cap of 10 simultaneous API requests under a fair use policy, not a per-minute quota, and Baserow states that self-hosted installs place no limits on rows, records, webhooks or API requests. There is no requests-per-minute number to budget against, which is why this connector holds a concurrency semaphore rather than a token bucket, and why the batch row nodes are the right answer to a big sync rather than a loop.

The last trap is the one that costs the most time. Baserow keys row cells by field id, as field_123, unless the user_field_names parameter is set, and that parameter is a query parameter that also governs the shape of POST and PATCH request bodies. Set it on a read, forget it on the write fed from that read, and Baserow answers 200 having changed nothing, because every key in your body was unrecognised. Every row node here defaults it to on, read and write alike, so the asymmetry the trap needs is not there, and the connector refuses a mismatched write before it leaves rather than letting it succeed emptily.

One connection, three surfaces

  • Visual automations. Drag Baserow nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Baserow node, ready to drop on the canvas

61 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 27

Baserow: Check Database 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Connecting Baserow takes one credential

The database token is created inside Baserow: click your workspace name in the top left, open Settings, and go to the Database tokens tab. It belongs to that one workspace and carries four independent permission toggles for Create, Read, Update and Delete, each of which can apply to every table in the workspace or only to tables you pick, so a read-only automation can hold a token that physically cannot write. Baserow states that database tokens do not expire, so revoking one in Baserow is the off switch. Creating a token is not a plan feature, though Baserow does document one role restriction under its Enterprise licence, where only workspace-level admins and builders can create database tokens. The optional half is different in kind and worth a deliberate decision. Baserow has no long-lived scoped key for the schema-level API, so the only way to reach workspaces, tables, views, webhooks, exports, snapshots and trash is an account email and password, which Mattering exchanges for a session token at run time. That password is a full account login and Baserow does not let you scope it down, so add it only if you need those nodes, and prefer a dedicated Baserow account with membership limited to the workspaces the automation should touch. An account with two-factor authentication turned on cannot be used for this half at all, because Baserow requires an authenticator code that an automation has no way to supply. That account can still hold and use a database token.

1

Decide which half of the connector you need. Rows, fields and batch writes run on the database token alone. Workspaces, databases, tables, views, webhooks, exports, snapshots, trash and search need the account email and password as well.

2

In Baserow, click your workspace name in the top left, open Settings, go to the Database tokens tab and create a token for the workspace the automation should work in. Tick only the Create, Read, Update and Delete boxes that automation actually needs, and narrow each to specific tables rather than the whole workspace where you can. An unticked box is not a silent no-op: the request comes back with an error naming the missing permission.

3

If you want the schema and operational nodes, decide which Baserow account holds the connection. Every node using that half acts as that account, so a dedicated account whose workspace membership matches the automation's scope beats an individual's personal login. Confirm two-factor authentication is off on it, because Baserow's session exchange cannot complete without an authenticator code.

4

In Mattering Automations, open Connectors, click Add Connector, choose Baserow and click Create new credential. Paste the database token, add the email and password if you need them, and set the base URL. Leave it at api.baserow.io for Baserow Cloud, or paste your own https origin with no path for a self-hosted install.

5

Click Test Connection. Mattering calls Baserow's token check endpoint, which Baserow built for exactly this purpose and which reads no data, and then, if you supplied them, exchanges the email and password for a session token. The two halves are reported separately, so a passing token with a failing login tells you which one to fix rather than leaving you guessing.

6

All 61 Baserow nodes appear in the canvas palette. Run Baserow: List Tables for Token first: it needs no other id, works on the token alone, and lists exactly the tables the row nodes can operate on, which is also where every table picker in this connector reads from.

Common uses for the Baserow MCP

Sync another system into Baserow without burning the concurrency cap

This is the case most people arrive with, and the shape matters more than the nodes. Read from wherever the data lives, then write with Baserow: Create Rows in Batch and Baserow: Update Rows in Batch rather than one node per record, because Baserow Cloud allows 10 concurrent API requests and a per-row loop spends that budget on overhead. Baserow: List Rows reads the existing state back, with the filters tree or a view id doing the narrowing, and Baserow: List Row Names resolves link row cells to the primary field values they point at without fetching whole rows from the linked table. There is no idempotency key anywhere on this API, so a retried run creates duplicates: dedupe on your side, or read before you write.

An agent that can answer questions from an operational table

Point an assistant at the read half and it can answer from the table rather than from its training data. Baserow: List Rows with a view id reuses filters a person already built in the Baserow interface, which is usually less work than describing them again. Baserow: Get Grid View Aggregations returns the sums, counts and averages configured on a view's footer, which is the cheap way to get a number out of a large table without reading its rows at all. Baserow: Search Workspace turns a human's phrasing into the application, table, view or row they meant when nobody knows the id. Baserow: Get Row History answers what changed on a record and who changed it, which is the question behind most escalations.

Triage that writes back where people actually look

Reading is half of it. Baserow: Update Row sets a status, an owner or a score on the record itself, and because it is a PATCH only the cells you send change. Baserow: Create Row Comment leaves the reasoning next to the record rather than in a run log, which is where a human will read it, though it is a Baserow premium feature and errors on a plan without it. Baserow: Upload File From URL has Baserow fetch a file from a public URL and store it, and the name it returns is what you write into a file cell with Baserow: Update Row. Comments are attributed to the account on the credential, not to whoever triggered the run, so name that account something a colleague will recognise.

Building the table, not just filling it

Most spreadsheet-database connectors stop at rows. This one can create the container. Baserow: Create Database and Baserow: Create Table stand up a new database and table, and Create Table takes an array of arrays with an optional header row, so an upstream node's tabular output can become a real Baserow table in one step. Baserow: Create Field adds columns, with the type-specific half passed through rather than guessed at, since Baserow models 29 field types separately. Baserow: Create View, Baserow: Create View Filter and Baserow: Create View Sort build the saved view a team will actually use. Handle Baserow: Update Field carefully: it deletes nothing and is still the sharpest node here, because changing a field's type converts every cell in the column and anything that will not convert is set to null.

Scheduled exports, snapshots and a real undo path

Baserow: Export Table starts an export in csv, json, xml, excel or file format and returns a job rather than a file, so Baserow: Get Export Job is the poll that collects the download URL once the state reaches finished. Only the csv exporter is in Baserow's open source core; the json, xml, excel and file exporters are all premium, which is worth knowing before a scheduled job fails on a free plan. Baserow: Create Snapshot takes a point-in-time copy of a whole database, which is the right thing to put in front of an unattended import or a mass delete, and Baserow: Restore Snapshot brings it back as a new database alongside the original rather than overwriting anything. Baserow: List Trash Contents and Baserow: Restore Trash Item are the undo behind the delete nodes, inside Baserow's retention window, which Baserow documents as 3 days on Cloud.

Webhook plumbing, including the part that is normally guesswork

Baserow: Create Webhook, Baserow: Update Webhook and Baserow: Delete Webhook manage the webhooks on a table from a workflow, which means a deployment can wire its own delivery rather than someone doing it by hand in a browser. Baserow: Test Webhook Call is the node that earns this family its place: it sends a test call and returns the exact request Baserow sent and the response it received, so the question of whether the receiver is reachable stops being a guess. Baserow: List Webhooks includes recent call results, which is where you look when a downstream automation stopped firing and nobody knows which side went quiet. One thing to design around: 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.

Example: A nightly sync into Baserow that takes a snapshot before it touches anything

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a nightly schedule fires. This connector has no trigger nodes, so Baserow workflows run on a schedule or on a trigger from another connector rather than listening for a push from Baserow.

2

Baserow: Create Snapshot takes a point-in-time copy of the target database. This is the step people skip and regret, because it is the difference between an unattended run that can be undone and one that cannot.

3

The source system is read by whichever connector owns it, and the result is shaped into an array of cell maps keyed by field name.

4

Baserow: List Rows reads the current state of the table through a saved view, so the comparison uses filters a person already built rather than filters restated in the workflow. Nothing pages automatically, so the loop and its cost against the 10 concurrent request cap are visible on the canvas rather than hidden inside one step.

5

Baserow: Create Rows in Batch writes the new records and Baserow: Update Rows in Batch amends the changed ones, one request each instead of one per row. Both default to keying cells by field name, which is the same keying the read used, so nothing silently returns 200 having changed nothing.

6

Baserow: Create Row Comment leaves a short note on any record the sync could not match, so the exceptions land next to the data instead of in a run log nobody opens. On a plan without Baserow premium, replace this step with a status field write using Baserow: Update Row.

7

A summary is posted to Slack or opened as a Mattering Productivity task. If the run needs unwinding, Baserow: List Trash Contents and Baserow: Restore Trash Item cover row-level mistakes and Baserow: Restore Snapshot covers the rest.

Baserow MCP questions, answered

What can this connector actually do in Baserow?

61 nodes: 27 read and 34 act, curated from the 410 operations Baserow documents. Reads cover rows, row names, row history, row comments, fields and their unique values, tables both by token and by database, views, view filters, view sortings, grid view rows and aggregations, webhooks, workspaces, databases, snapshots, trash contents, export jobs, async jobs, workspace search, Baserow MCP endpoints, and the token check. Writes cover creating, updating, deleting and moving rows including the three batch endpoints, creating and updating fields and tables, creating databases, creating and updating views with their filters and sorts, full webhook management including a test call, table exports, snapshots and snapshot restore, trash restore, row comments, file upload from a URL, and creating Baserow MCP endpoints. Not included, and worth knowing before you plan: Baserow's Application Builder, its own automation engine and its dashboards; instance and account administration; the user and authentication endpoints; AI provider configuration and the AI assistant; teams, role assignments and field permissions; the audit log; workspace invitations; the notification inbox; and the anonymous public-share endpoints. Baserow: API Request is an advanced node that reaches any of them.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and work with Baserow through them. Matter, the assistant built into the platform, uses the same nodes natively. The same nodes are also steps on the automation canvas, so a workflow an agent helps you design then runs on a schedule with nobody present. A sensible split is to hand an assistant the 27 read nodes and put the writes behind a condition or an approval step, especially the eleven flagged destructive.

Baserow has its own MCP server. Why would I use this one?

It does, and it is a good one. Baserow ships a native, built-in MCP server: you create an MCP endpoint, Baserow gives you a URL with a secret in it, and you paste that into an MCP client. If your goal is a chat window that can read and write rows in your workspace, use Baserow's own server. This connector answers a different question. Its nodes are canvas steps as well as MCP tools, so the same capability runs unattended on a schedule or a trigger with nobody in the chat window; it chains with every other connector in one workflow, so a Baserow row can become a Slack message, an invoice, or a task in another system without leaving the canvas; the credential lives once in a shared workspace store rather than in each person's local client config, and can be a scoped database token rather than a workspace-wide key; and destructive nodes are flagged so a workflow can gate on them. The two also compose: Baserow: List MCP Endpoints and Baserow: Create MCP Endpoint let an automation provision Baserow's own MCP endpoints. Be careful with the output, because it contains the endpoint key, and Baserow's own advice is to treat that URL like a password.

Does this work with a self-hosted Baserow?

Yes, and it is the same connector rather than a variant. Baserow is open source and widely self-hosted, and the base URL is a field on the credential, so pointing the nodes at your own install is a matter of pasting your origin instead of api.baserow.io. Everything else is identical: the same 61 nodes, the same database token, the same optional account login. Two differences are in your favour on a self-hosted install. There is no concurrency cap out of the box, because Baserow states that a self-hosted install will never place limits on rows, records, webhooks or API requests, and the concurrency throttle its configuration does offer ships disabled. And the trash retention window is a configuration setting on your side, rather than the 3 days Baserow documents on Cloud. One requirement: the origin must be https. Plain http is refused, because a database token and an account password are both full-strength credentials and neither belongs on the wire in clear text.

Why does the credential want a token and a password?

Because Baserow's API has two authentication systems and each reaches a different half of it. A database token is workspace-scoped, never expires, carries independent Create, Read, Update and Delete toggles, and reaches the row-level data plane, which is sixteen of the sixty one nodes here: every row read and write, the three batch endpoints, field listing and creation, the token's table lister, the token check and the URL file upload. Everything structural, which is workspaces, databases, tables, views, webhooks, exports, snapshots, trash and search, is served only to a logged-in session, so the only way to reach it is an account email and password exchanged for a short-lived session token. Baserow is explicit that a database token only reads and manipulates the data of a table and that structural changes need a session token, and it ships no scoped key for that half at all. Watch the naming while you look for one: Baserow's own documentation uses personal API tokens as a synonym for database tokens rather than for a second credential type. Making the token required and the login optional is deliberate: a row writer that cannot list a table is not a useful connector, and forcing a full account login on someone who only wants to write rows is not a reasonable trade. If you leave the email and password empty, the schema nodes tell you exactly what is missing instead of returning a bare authentication error. One limitation to know: an account with two-factor authentication turned on cannot complete the session exchange, because Baserow asks for an authenticator code an automation cannot supply. That account can still hold a database token.

What are Baserow's rate limits?

Baserow Cloud publishes a limit of 10 concurrent API requests, under a fair use policy, and Baserow reserves the right to lower it. That is a concurrency cap rather than a per-minute quota, and no requests-per-minute number is published anywhere, so there is nothing to budget against in the usual sense. Self-hosted Baserow has no such limit at all: Baserow states that a self-hosted install will never place limits on rows, records, webhooks or API requests. Practically this shapes workflow design in one direction: prefer the batch nodes. Baserow: Create Rows in Batch and Baserow: Update Rows in Batch each write many rows in a single request, where a per-row loop spends the concurrency budget on overhead. Nothing in this connector auto-paginates either, so a page-by-page walk is a visible loop on the canvas rather than an unbounded number of requests hiding behind one step, and a polling node such as Baserow: Get Export Job needs a wait between iterations because polls count too.

Why did a request come back 404 when the URL looks right?

Almost always a missing trailing slash. Baserow's API requires one on every path and does not redirect, so a URL that looks right simply does not route. It is at least an honest 404: the body carries an error of URL_TRAILING_SLASH_MISSING and a detail naming the URL you should have called. Every path shipped in this connector ends in a slash, and the module asserts that at import time so it cannot rot, so this only reaches you through Baserow: API Request, the passthrough node, where the path is yours to type. That node re-adds a missing trailing slash before the query string rather than letting the request fail. The other common 404 is not a routing problem at all but an id from the wrong place: a table id from one workspace used with a token scoped to another comes back as a not-found rather than as a permission error.

Why did a write return 200 without changing anything?

This is Baserow's user_field_names trap, and it is the single most expensive thing to learn the hard way. Baserow keys row cells by field id, as field_123, unless user_field_names 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 a row with names on, feed it into a write with the parameter off, and Baserow accepts the write, returns 200, and changes nothing, because every key in the body was unrecognised. Two things in this connector remove it. Every row node defaults user_field_names to on, read and write alike, so there is no asymmetry to fall into. And when it is turned off, the connector checks the payload's keys before sending and returns an error naming the offending ones rather than letting a request succeed emptily. If you do turn it off, run Baserow: List Fields first: that is where the field_123 keys come from.

What happens when a workflow deletes something in Baserow?

Eleven nodes are flagged destructive and they are not one thing. Most of the deletes send the object to Baserow's trash, so Baserow: Restore Trash Item can bring back a row, field, table, 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. Treat that as a recovery path rather than a safety net, and put Baserow: Create Snapshot in front of anything unattended. Three of the eleven deserve a closer look. Baserow: Update Field deletes nothing and is the most dangerous node here, because changing a field's type converts every cell in the column and anything that will not convert is set to null, with no per-cell report; leave the type empty if you only meant to rename. Baserow: Delete View Filter removes no rows at all but immediately reveals the rows the view was hiding, including through any public share link on it, which makes it a disclosure event rather than a data one. And Baserow's own note on the batch delete endpoint is that it does not yet work with row deleted webhooks, so anything listening for that event misses removals made with Baserow: Delete Rows in Batch and looks broken rather than un-notified. Baserow: API Request carries the flag too, because a free-text method and path can be anything.

Do I need a paid Baserow plan?

Not for most of this connector. Baserow's REST API and database tokens are part of the open source core rather than a plan feature, and self-hosting is a second route with no request limits at all. What Baserow Cloud's free plan meters is data rather than calls: Baserow documents 3,000 rows and 2GB of storage per workspace on the free plan, and states that a workspace over its row limit for 7 days stops being able to create new rows. Two things here do depend on Baserow premium. Row comments, which is Baserow: List Row Comments and Baserow: Create Row Comment. And most of the export formats: only csv is in the open source core, while json, xml, excel and file are all premium, so Baserow: Export Table works on a free plan in csv and errors in the other four. Those errors are a legitimate answer from Baserow rather than a broken connection. Snapshots are the third place a plan shows, since Cloud plans set how many you can keep.

61 nodes waiting on the canvas

Put Baserow to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Baserow is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products