Mattering Automations Stackby integration
Connect Stackby to Mattering Automations: stacks, tables, columns and views, plus row reads, batched creates, partial updates and deletes on the Stackby Developer API v1, authenticated with one API key from your account settings.
The Mattering Automations Stackby integration puts the Stackby Developer API v1 on your automation canvas: list the stacks in a workspace, list a stack's tables, columns and views, read rows with filtering, sorting and a view restriction, fetch specific rows by id, poll a view for the newest rows, create and partially update rows in batches, and create or delete stacks, tables and columns.
The credential is a single API key created in your Stackby account settings and sent as an HTTP header. There is no OAuth, no key and secret pair, and no subdomain to work out. One awkwardness is handled for you rather than passed on: Stackby's own documentation disagrees with itself about the header name, so Mattering sends both documented spellings with the same value and you never have to pick.
One setup difference is worth reading before you start, because its absence looks like a missing feature. This integration ships no Test Connection button, deliberately. Stackby's Developer API has no authenticated read that works without an id: every path is stack-scoped or table-scoped, and the one workspace-level lister is a POST with a JSON body rather than a plain GET, so no static probe can return success for a valid key. Verification is a real node instead, and the Verify the connection section below walks it.
Before you start
- A Stackby account that can create an API key in account settings. Stackby's pricing page ticks the Developer API row on every plan including Free, and the tooltip on that same row describes the API as currently in beta, so both facts are worth carrying into a production decision.
- The workspace id of the workspace you want to reach, taken from the workspace URL. Stackby's stack lister is workspace-scoped and the Developer API publishes no workspace-list endpoint, so this is the one value you supply by hand. Everything below it is a picker.
- At least one stack, or the intent to create one. Stackby: Create Stack works from the canvas, and because Stackby publishes delete endpoints for stacks, tables and columns, structure created from a workflow can be cleaned up by one.
- An understanding that deletes here are permanent. The Developer API publishes no trash, no restore and no undelete endpoint, and the vendor's own wording for a stack is that it deletes it permanently. Whether the Stackby web interface keeps history of its own is not addressed by the API reference, so an automation must not rely on one.
- A Mattering workspace with access to the Automations app.
- Not required and not stored here: a stack id, table id or view id. Those come from the listers as pickers, in the order stack, then table, then view or column.
Create a Stackby API key
Stackby authenticates every request with one API key from your account settings. There are no scopes to compose and no environments to choose, so the only real decisions are which account creates the key and which workspace you intend to automate.
Connect Stackby to Mattering
Verify it works
Open any automation canvas and check the palette for a Stackby section. Drop Stackby: List Stacks onto the canvas, put your workspace id into Workspace ID, and run a test step. This is the integration's real credential check: a list of your stacks with their ids proves the key, the host, the path and the header placement in one call. A 401 here means the key is missing or wrong. It is a read despite being sent as a POST, because Stackby takes the workspace id in a JSON body rather than on the path.
Now walk one level down to confirm the picker chain. Drop Stackby: List Tables onto the canvas and open its Stack picker: it should list the stacks that first node returned, by name. Choose one, run the step, and you get the stack's tables with their ids. Then run Stackby: List Columns against one of those tables. Do this even if you already know the table, because the column names it returns are the exact keys every row write has to use.
Finish with a read of real data: Stackby: List Rows against the same table, with a small page size. Each row comes back as an id plus a field map keyed by column name. Two things to notice while you are here, because both change how you write the next step. Empty cells are omitted from the field map entirely rather than returned as empty values, and paging is by a starting row number rather than a cursor. Everything in this path is read-only, so it cannot reach any of the four destructive nodes and is safe to re-run whenever you regenerate the key.
Node reference
16 nodes, generated from the connector itself so this reference always matches what ships.
Read and query nodes 7
Stackby: Get Rows By Id
stackby_get_rows
Fetch specific rows by id. Same endpoint as Stackby: List Rows, narrowed to the ids you name (sent as the documented rowIds[] repeat parameter) and split out as its own node because pulling known rows is a different job from listing a table. Empty cells are omitted from each row's 'field' map.
Stackby: List Columns
stackby_list_columns
List every column of a table with its id, name and type. Two jobs: it supplies the column ids that Stackby: Delete Column and the link/lookup column types need, and because row cells are keyed by COLUMN NAME it is also how an automation discovers the keys to use in a Create Rows or Update Rows body. Stackby's published spec documents no rate limit and no 429 contract, so treat throughput as unknown and put a delay between batches.
Stackby: List Rows
stackby_list_rows
List rows from a table, with filtering, sorting, a view restriction and offset paging. Each row comes back as {id, field}, where 'field' is the cell map keyed by column NAME; empty cells are omitted entirely rather than returned as empty values. Paging is by OFFSET (a starting row number, not a cursor) at up to 100 rows per page, and nothing in the response says whether more rows remain, so a drain loop stops when a page comes back short. Stackby's published spec documents no rate limit and no 429 contract, so treat throughput as unknown and put a delay between batches.
Stackby: List Stacks
stackby_list_stacks
List every stack in a workspace. This is where the stack ids (stqXXX) used by every other Stackby node come from, which makes it the root of the connector's picker chain. A read despite the POST: Stackby takes the workspace id in a JSON body rather than on the path. Stackby's published spec documents no rate limit and no 429 contract, so treat throughput as unknown and put a delay between batches.
Stackby: List Tables
stackby_list_tables
List every table in a stack, with its id (tbmXXX) and name. This is the second link in the picker chain: the table ids the row, column and view nodes need come from here. Stackby's published spec documents no rate limit and no 429 contract, so treat throughput as unknown and put a delay between batches.
Stackby: List Views
stackby_list_views
List a table's views with their ids (vwXXX) and names. The vendor's own docs point every view id here: it is what Stackby: New Rows In View and the column nodes need, and the view NAME is what Stackby: List Rows filters by. Stackby's published spec documents no rate limit and no 429 contract, so treat throughput as unknown and put a delay between batches.
Stackby: New Rows In View
stackby_new_rows_in_view
Return the newest rows in a view, capped at 15 when no limit is given. This is the closest thing Stackby's API has to a new-row trigger: poll it on a schedule and dedupe on row id downstream. It does NOT push, and it has no since-cursor, so a poll slower than the row arrival rate can miss rows - pair it with Stackby: List Rows sorted by latest for a backstop.
Action nodes 9
Stackby: Create Column
stackby_create_column
Add a column to a table. The column TYPE travels on the path, and some types need extra body fields (options for single/multiple option, the link fields for link, lookup, lookup count and aggregation). Reversible from an automation: Stackby: Delete Column removes it again, which is why this is a Reversible Write rather than a one-way schema change.
Stackby: Create Rows
stackby_create_rows
Create up to 10 rows in one call. Each row is a {"field": {...}} object keyed by COLUMN NAME (run Stackby: List Columns if you do not know them). To fill an attachment column, put one or more public URLs in the cell as a comma-separated string and Stackby fetches them server-side. The response returns the created rows with their new ids. Stackby's published spec documents no rate limit and no 429 contract, so treat throughput as unknown and put a delay between batches.
Stackby: Create Stack
stackby_create_stack
Create a new, empty stack inside a workspace. Reversible from an automation: Stackby: Delete Stack can remove it again (permanently, so a cleanup step is a real delete, not a move to trash).
Stackby: Create Table
stackby_create_table
Create a new table inside a stack, optionally copying another table's structure or data. Reversible from an automation: Stackby: Delete Table removes it again.
Stackby: Delete Column
stackby_delete_column
Delete a column from a table. DESTRUCTIVE: every cell value in that column, across every row, goes with it, and the API publishes no restore endpoint. Note the shape - the stack id is on the path while the table, view and column ids travel in the request body.
Stackby: Delete Rows
stackby_delete_rows
Delete up to 10 rows by id in one call. DESTRUCTIVE: the API publishes no restore endpoint, so a row deleted here is not recoverable through an automation. Ids are sent as the documented rowIds[] repeat parameter; a single id deletes one row.
Stackby: Delete Stack
stackby_delete_stack
Delete a stack and everything in it. DESTRUCTIVE and the widest blast radius in this connector: the vendor's own wording is 'Deletes a stack permanently', every table, column, view and row inside goes with it, and the API publishes no restore endpoint. Nothing here is recoverable through an automation.
Stackby: Delete Table
stackby_delete_table
Delete a table from a stack. DESTRUCTIVE: the table's columns, views and every row in it go with it, and the API publishes no restore endpoint, so nothing is recoverable through an automation.
Stackby: Update Rows
stackby_update_rows
Partially update up to 10 rows in one call: only the columns you send change, everything else is left alone. Each row object needs its "id" and a "field" map keyed by column NAME. Attachment columns take comma-separated public URLs. Stackby also documents a PUT variant of row update; it is deliberately not shipped, because a replace whose body omits a column silently clears it. Stackby's published spec documents no rate limit and no 429 contract, so treat throughput as unknown and put a delay between batches.
Using the integration
On the automation canvas
Stackby nodes chain with every other node. A webhook or a form submission can land a record with Stackby: Create Rows, a schedule can pull a table into a Mattering database for reporting, and an enrichment step can write results back with Stackby: Update Rows. The ids are pickers wherever a lister exists, in the order the vendor's own documentation describes: stacks from Stackby: List Stacks, tables from Stackby: List Tables, then views from Stackby: List Views and columns from Stackby: List Columns. The workspace id is the one value you type, because the Developer API publishes no workspace lister to populate it from.
From AI assistants over MCP
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. The sequence that works for an agent is discovery first: Stackby: List Stacks, then Stackby: List Tables, then Stackby: List Columns to learn what the cells are actually called, and only then Stackby: Create Rows or Stackby: Update Rows. The listers, the row reads and the two write nodes are a comfortable surface for an agent; keep the four deletes behind a condition or an approval task. Running the nodes here rather than as a local tool also means they work on a schedule with nobody present, chain with every other connector in one workflow, and hold the key in the workspace credential store rather than in one person's client config.
Cells are keyed by column name, and what that means
This is the single most important thing to know about automating Stackby. A row is an id plus a field map, and that map is keyed by the column's NAME rather than by a stable column id. There is no name-independent write path. So renaming a column in the Stackby interface means every Stackby: Create Rows and Stackby: Update Rows body still carrying the old name writes nothing into that column, and reports success while doing it. The durable pattern is to run Stackby: List Columns inside the workflow and build the payload from the names it returns, rather than from names copied once at build time. The mirror image applies to reads: empty cells are omitted from the field map rather than returned as empty values, so treat a missing key as empty and not as a failure.
Writing rows in batches of ten
Stackby: Create Rows, Stackby: Update Rows and Stackby: Delete Rows all take at most 10 rows per call, so larger sets are looped in tens. Stackby: Update Rows is a partial update: only the columns you send change and the rest are left alone, which makes it the right node for enrichment on rows other people own. Stackby also documents a replace-style variant of row update, which this integration deliberately does not build, because a replace whose body omits a column silently clears it. Clearing a single cell on purpose still works by sending it empty through the partial update. Attachment columns need no file handling on your side: put one or more public URLs in the cell as a comma-separated string and Stackby fetches them server-side.
Reading, filtering and offset paging
Stackby: List Rows filters, sorts, restricts to a view and pages with a limit, which Stackby's spec defaults to 25, and an offset; no maximum page size is published. Two shapes to design around. Paging is by OFFSET, and offset is a starting row number rather than an opaque cursor: Stackby's documentation says that to read from row 5 you pass 5. Nothing in the response says whether more rows remain, so a drain loop stops when a page comes back shorter than the page size and keeps count itself. And one field is easy to get backwards: the view restriction on Stackby: List Rows takes a view NAME, while every other view field in the integration takes a view ID, so passing an id there filters nothing. Both values come from Stackby: List Views, which is why that node feeds two different pickers. Stackby: Get Rows By Id is the narrower read for rows you already know.
Polling for new rows, because there is no trigger
Stackby publishes no webhook and no change trigger, so event-shaped work is polled. Stackby: New Rows In View returns the newest rows in a view, capped at 15 when no limit is set, and the working pattern is a schedule plus a dedupe on row id in a Mattering database. Read its limits honestly: there is no since-cursor, so a poll slower than the rate rows arrive can miss rows entirely. Pair it with Stackby: List Rows sorted by latest as a backstop, and set the schedule faster than rows realistically appear. There is no change feed for edits or deletes at all, so a workflow that needs to notice an edit has to compare against its own stored copy.
Building structure from a workflow
Stackby: Create Stack, Stackby: Create Table and Stackby: Create Column can stand up a working stack as part of an onboarding run, and Stackby: Create Table can copy another table's structure or data. These are reversible writes rather than one-way doors, because Stackby publishes delete endpoints for tables and columns, which also makes a self-cleaning test round trip possible inside one scratch stack. Two shapes to expect: the column TYPE travels on the path rather than in the body, and the link, lookup, lookup count and aggregation types additionally need foreign table ids that the common body does not carry, so sending the common body alone will not create them. Stackby: Delete Column has an unusual shape of its own: the stack id is on the path while the table, view and column ids travel in the request body.
The four destructive nodes, gated
Stackby: Delete Stack is the widest: every table, column, view and row inside it goes, and the vendor's own wording is that it deletes the stack permanently. Stackby: Delete Table takes its columns, views and rows. Stackby: Delete Column takes that column's value in every row of the table. Stackby: Delete Rows takes up to ten named rows per call. None of them is recoverable through an automation, because the Developer API publishes no trash, no restore and no undelete endpoint anywhere. This guide makes no claim about what the Stackby web interface does or does not keep, because the API reference does not address it, and an automation must not depend on an answer nobody has published. The pattern for all four is the same: read what you are about to remove first, gate the delete behind a condition or an approval task rather than a bare trigger, and copy anything that matters into a Mattering database before the run rather than after.
Troubleshooting
There is no Test Connection button on this connector
Stackby: List Stacks returns 401
Stackby: List Stacks returns an empty list
A workflow gets 429 responses partway through a loop
A row write succeeds but a column stays empty
A template reference to a cell resolves to nothing
Paging never ends, or the same rows come back again
A view filter on List Rows does not filter anything
Creating a link, lookup or aggregation column does not work
Something was deleted and needs to come back
Related
The Stackby MCP
What connecting Stackby unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
Stackby 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.