Menu

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.

Sign in to Stackby and open your Account settings.
Find the API Key section and copy the key.
The key carries its owner's access, and this integration's four delete nodes remove stacks, tables, columns and rows with no restore endpoint published anywhere in the API. Create the key under an account whose access matches the automation, and regenerate it from the same page if it ever leaks.
Open the workspace you want to automate and copy its workspace id from the URL. Stackby's stack lister is scoped to a workspace and the Developer API publishes no workspace lister, so this is the one id you supply rather than pick.

Connect Stackby to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Stackby from the list.
Click Create new credential, paste the API key, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs. Mattering sends the key under both header spellings Stackby's documentation uses, so there is no header name to configure.
Click Connect. All 16 Stackby nodes appear in your canvas palette.
There is no Test Connection button on this integration and that is deliberate, not an omission. Stackby's API has no authenticated read that works without an id, so a static probe would answer with an error for a perfectly valid key. Verify with a node instead, as below.

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
Expected, and deliberate. Stackby's Developer API has no authenticated read that works without an id: every path is scoped to a stack or a table, and the one workspace-level lister is a POST with a JSON body rather than a plain GET, so no static probe can answer 200 for a valid key. A probe against a placeholder id returns an error even when the credential is perfect, which would show a failure to someone whose setup is fine. Verify with Stackby: List Stacks and your workspace id instead: it proves the key and hands you the stack ids at the same time.
Stackby: List Stacks returns 401
The key was missing or rejected. Check for leading or trailing whitespace from the copy, and confirm the key still exists in your Stackby Account settings, regenerating it there if you are not sure. You do not need to configure a header name: Mattering sends the key under both spellings Stackby's own documentation uses, because the vendor's authentication section and its per-endpoint examples disagree with each other. If the key is definitely current and a 401 persists, confirm the account itself can open the workspace in the Stackby interface.
Stackby: List Stacks returns an empty list
The workspace id is the thing to check, not the key. That lister is workspace-scoped and takes the id in its body, so a wrong or stale id returns nothing rather than an error. Copy the id again from the workspace URL in Stackby. This is also the one value in the integration you have to supply by hand: the Developer API publishes no workspace-list endpoint, so there is no picker to populate it from, and the id you type is what every stack picker below it reads.
A workflow gets 429 responses partway through a loop
Stackby's published OpenAPI spec documents no rate limit and no 429 contract, so this guide quotes no number and you should treat throughput as unknown. The connector adds no retry logic of its own, so backoff belongs in the automation: space the batches. Mattering batches row writes in tens, so a large set is inherently several requests. Stackby also documents 502 as its servers restarting, which is safe to retry, and 503 as a retry with backoff.
A row write succeeds but a column stays empty
This is the column-name trap and it is the most common silent failure on Stackby. Cells are keyed by column NAME rather than by a stable id, so a column renamed in the Stackby interface no longer matches the key your body is sending, and the write succeeds while filling nothing. Run Stackby: List Columns against the table and compare the names against the payload. The durable fix is to make that lookup a step in the workflow so the payload is built from the current names on every run rather than from names copied once.
A template reference to a cell resolves to nothing
Empty cells are omitted from a row's field map entirely, rather than being returned as an empty string, an empty list or false. So a reference to a cell that happens to be empty resolves to nothing and does not raise, which is not an error and will not fail the node. Handle it downstream with a default rather than treating a missing key as a fault. If a key you expect is missing on every row rather than some, check the spelling against Stackby: List Columns instead, because that is a name mismatch rather than an empty cell.
Paging never ends, or the same rows come back again
Offset on Stackby: List Rows is a starting ROW NUMBER, not a cursor. There is nothing in the response to feed back into the next call: no next field, no offset echo and no has-more flag. A loop written for a cursor-based API therefore passes the same value forever and re-reads the first page. Do the arithmetic in the workflow instead: add the page size to the offset each iteration, and stop when a page comes back shorter than the page size. The maximum record parameter caps the total but does not remove the paging: the vendor notes that if it exceeds the page size you still have to walk pages to reach it.
A view filter on List Rows does not filter anything
That field takes a view NAME while every other view field in the integration takes a view ID, which is the vendor's own asymmetry rather than ours. Passing an id where a name is expected matches no view and filters nothing, silently. Both values come from Stackby: List Views, so open that node's output and take the name for Stackby: List Rows and the id for Stackby: New Rows In View and the column nodes.
Creating a link, lookup or aggregation column does not work
Those types need more than the common body. The column TYPE travels on the path rather than in the body, and the link, lookup, lookup count and aggregation types additionally require the foreign table's ids, which the common body does not carry, so sending it alone will not create them. Fill in the link fields for the target table. Note also that the foreign table's view and column pickers cannot be scoped from this form, because the only table id on it is the table being edited, so those two fields are free text on purpose rather than broken pickers: read the ids from a separate Stackby: List Views or Stackby: List Columns run against the target table.
Something was deleted and needs to come back
There is no path back through the API, so this is a question of preparation rather than recovery. Stackby's Developer API publishes no trash, no restore and no undelete endpoint for stacks, tables, columns or rows, and the vendor's own wording for a stack delete is that it is permanent. This guide makes no claim about what the Stackby web interface retains, because the API reference does not address it. Going forward, gate the four delete nodes behind a condition or an approval task, and have the workflow read what it is about to remove into a Mattering database first, so at minimum the run record holds a copy.

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.

Start Free Explore our Products