Menu
Mattering Automations connector

A Stackby MCP for agents that work the rows, not just read them

Connect one Stackby API key and 16 nodes land on the canvas: list stacks, tables, columns and views, read rows with filtering and sorting, create and update rows in batches, and build or tear down structure. An AI assistant can look up the right table, discover what its columns are actually called, and write a row back, with the result sitting next to your tasks and databases.

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

What the Stackby MCP connector does

The Stackby connector for Mattering Automations is 16 nodes on the Stackby Developer API v1: stacks (list, create, delete), tables (list, create, delete), columns (list, create, delete), views (list), and rows (list, get by id, newest in a view, create, update, delete). That covers 15 of the 16 endpoints Stackby publishes, plus a second node on the row list endpoint for fetching known rows by id. The one endpoint not built is file upload, which is a multipart form carrying real file bytes; attachment columns are still reachable, because Stackby fetches public URLs server-side when you put them in an attachment cell.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. That matters more than usual on Stackby, because the API keys cells by column NAME rather than by column id: an agent that runs Stackby: List Columns first can write against the names the table actually has today rather than the names it had when someone wrote the workflow.

The version is pinned to v1 deliberately. Stackby's own developer reference states that the older betav1 and v0 versions were to be deprecated in 2025 and tells callers to move to v1, and much of the third-party example code still in circulation is written against the old paths. Every path in this connector is v1. The vendor also labels the Developer API itself as currently in beta on its pricing page, so treat undocumented behaviour as something to verify rather than assume.

The safety modeling is stated rather than implied. Of the 16 nodes, 7 read and 9 act, and four are flagged destructive: Stackby: Delete Stack, Stackby: Delete Table, Stackby: Delete Column and Stackby: Delete Rows. Nothing here is recoverable through an automation, because the Developer API publishes no trash, no restore and no undelete endpoint, and Stackby's own wording for a stack is that it deletes it permanently. Whether the Stackby web interface keeps any history of its own is not addressed by the API reference at all, so this page makes no claim about it and an automation must not depend on one. Blast radius, widest first: deleting a stack takes every table, column, view and row inside it, deleting a table takes its columns, views and rows, deleting a column takes that column's value in every row, and deleting rows takes up to ten named rows per call.

One connection, three surfaces

  • Visual automations. Drag Stackby 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 Stackby node, ready to drop on the canvas

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

Read and query nodes 7

Stackby: Get Rows By Id

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Connecting Stackby takes one credential

Stackby authenticates with a single API key, created in your Stackby account settings and sent as an HTTP header on every request. There is no OAuth, no key and secret pair, and no account or subdomain component to work out. One detail is handled for you: Stackby's own documentation disagrees with itself about the header name, with the authentication section naming one spelling and every saved request and per-endpoint example naming another, so Mattering sends both spellings with the same value rather than making you guess. On availability, two facts belong together and this page states both. Stackby's pricing page ticks the Developer API row on every plan including Free, and the tooltip on that same row calls it currently in beta. Do not confuse that row with the separate Automatic API Runs Per Month Per Stack row, which is Stackby's API column feature for pulling third-party data into a stack and has nothing to do with this connector. On throughput, Stackby's published OpenAPI spec documents no rate limit and no 429 contract, so treat it as unknown and put a delay between batches rather than designing against a number. Mattering batches row writes in tens.

1

Open your Stackby account settings and create an API key, then copy the value.

2

Note the workspace id of the workspace you want to reach. Stackby's stack lister is workspace-scoped, and the id is in the workspace URL.

3

In Mattering Automations, open Connectors, click Add Connector, choose Stackby, and create a credential with the key.

4

This connector ships no connection test, on purpose. 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, so a static probe returns an error for a perfectly valid key. Rather than show a red cross to someone whose credential is fine, the verify step is a real node.

5

Drop Stackby: List Stacks onto a canvas, put in the workspace id, and run a test step. It returns every stack in the workspace with its id, which both proves the key and gives you the ids everything else needs.

Common uses for the Stackby MCP

Discover the column names before writing a single row

This is the habit that makes Stackby automations durable. Row cells are keyed by column NAME rather than by a stable column id, so Stackby: List Columns is not a nicety, it is the lookup that tells a workflow which keys a Stackby: Create Rows or Stackby: Update Rows body should carry. Rename a column in the Stackby interface and every write built against the old name silently stops filling that column, with no error to notice, so a workflow that reads the current names each run keeps working through a rename that would otherwise break it quietly.

Land inbound records in a stack as they arrive

A form submission, a webhook from another system, or an agent's own output goes into Stackby: Create Rows, which takes up to ten rows per call keyed by column name. Attachment columns are reachable without any 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. The response returns the created rows with their new ids, so the next step can act on exactly what this one made rather than searching for it.

Enrich rows in place without clobbering the rest

Stackby: Update Rows is a partial update: only the columns you send change and everything else is left alone. That makes it the right node for enrichment, where a lookup step fills in two fields on a row somebody else owns. The replace-style variant Stackby also documents is deliberately not built, because a replace whose body omits a column silently clears it, which is exactly the failure this connector's destructive-flag policy exists to prevent. Clearing one cell on purpose is still possible by sending it empty through the partial update.

Poll for new rows and act on them

Stackby publishes no webhook and no change trigger, so the honest pattern is polling. Stackby: New Rows In View returns the newest rows in a view, capped at 15 when no limit is given, which a schedule can run every few minutes with a dedupe on row id downstream. Read the limitation with it: it has no since-cursor, so a poll slower than the rate rows arrive can miss some. Pairing it with Stackby: List Rows sorted by latest as a backstop is what makes the pattern reliable rather than approximately reliable.

Report across a stack on a schedule

Stackby: List Rows supports filtering, sorting, a view restriction and offset paging, so a scheduled run can pull the current state of a table into a Mattering database, chart it in Analytics, or open a task when a value crosses a line. Two shapes to design around rather than discover: empty cells are omitted from a row's field map entirely rather than returned as empty values, so a downstream step must treat a missing key as empty and not as an error, and paging is by a starting row number rather than a cursor, so a drain loop counts rows itself.

Build and tear down structure from a workflow

Stackby: Create Stack, Stackby: Create Table and Stackby: Create Column can stand up a working stack from a template as part of an onboarding run, optionally copying another table's structure or data. Because Stackby publishes both delete-table and delete-column endpoints, creating structure is a reversible write here rather than a one-way door, which also makes a self-cleaning test round trip possible inside one scratch stack. Two shapes catch people out: the column TYPE travels on the path rather than in the body, and link, lookup, lookup count and aggregation types additionally need foreign table ids that the common body does not carry.

Example: Poll a view for new rows, enrich them, and file the result

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

1

Trigger: a schedule fires every few minutes and runs Stackby: New Rows In View against the view where new records land. Because that endpoint has no since-cursor and defaults to 15 rows, the schedule is set faster than rows realistically arrive and a Stackby: List Rows step sorted by latest runs alongside it as a backstop.

2

A condition drops anything whose row id has already been processed, using a Mattering database of seen ids as the dedupe store, since the API offers no cursor to remember.

3

Stackby: List Columns reads the table's current column names, and the mapping step keys its payload from that rather than from names hard-coded when the workflow was built.

4

An enrichment step, an HTTP node or an AI node produces the extra values, and Stackby: Update Rows writes them back in batches of ten, which is the vendor's per-call cap. The workflow spaces the batches, because Stackby publishes no rate limit to design against.

5

A Mattering task opens for a person only when the enrichment step could not fill a required field, with the row id and stack link attached.

Stackby MCP questions, answered

What Stackby operations are supported?

16 nodes: 7 read and 9 act. Stacks (list, create, delete), tables (list, create, delete), columns (list, create, delete), views (list), and rows (list with filtering, sorting, view restriction and offset paging, get specific rows by id, newest rows in a view, create up to ten, update up to ten partially, delete up to ten). That is 15 of the 16 endpoints Stackby's Developer API publishes, plus a second node on the row list endpoint for fetching known ids. Deliberately not built: the file upload endpoint, which is a multipart form carrying binary file bytes that this connector layer has no file source to feed, and the replace-style row update, because a replace whose body omits a column silently clears it. Also not built: anything from Stackby's internal application API, which is a different surface with different authentication.

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 use them. Matter, the assistant built into the platform, uses the same nodes natively. What you get from running them here rather than as a local tool: they also run on a schedule with nobody present, chain with every other connector in one workflow, hold the Stackby key in a shared workspace credential store rather than in an individual's config, and carry destructive flags you can gate on.

Why is there no Test Connection button for Stackby?

Because a green tick would be a lie and a red cross would be worse. 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 single workspace-level lister is a POST with a JSON body rather than a plain GET, so there is no static probe that returns success for a valid key. A probe against a placeholder id answers with an error even when the credential is perfect. Instead, verify with a real node: drop Stackby: List Stacks onto a canvas, give it your workspace id, and run a test step. If it returns your stacks, the key works, and you now have the ids the rest of the connector needs.

Is the Stackby API available on the free plan?

Both halves of the answer belong together. Stackby's pricing page ticks the Developer API row on every plan column including Free, and the tooltip on that same row describes it as currently in beta. So yes, a free account can create a key and call the API, and yes, the vendor itself labels the API as beta, which is a reason to verify undocumented behaviour rather than rely on it. One row on that page is easy to misread: Automatic API Runs Per Month Per Stack is Stackby's API column feature, which pulls third-party data into cells inside a stack, and has nothing to do with this connector. Check the pricing page for the current state before you commit a production workflow to it.

What are Stackby's rate limits and batch sizes?

Stackby's published OpenAPI spec documents no rate limit and no 429 handling, so throughput is unknown and this page quotes no number. The connector adds no retry logic of its own, so backoff belongs in the automation: put a delay between batches. Mattering batches row writes in tens. Row listing takes a limit, which the spec defaults to 25, and an offset; no maximum page size is published. Stackby also documents 400, 401, 500, 502 and 503 responses, and describes 502 as its servers restarting, which is safe to retry.

How does paging work when I read a big table?

By offset, and offset here is a starting row number rather than an opaque cursor: Stackby's own documentation says that to read from row 5 you pass 5. Nothing in the response says whether more rows remain, because there is no next field, no offset echo and no has-more flag, so a drain loop stops when a page comes back shorter than the page size and does the arithmetic itself. This is the difference that breaks a workflow copied from a cursor-based system, where the loop passes back a value the response handed it.

Can an AI agent delete something I cannot get back?

Yes, which is why the four delete nodes are flagged destructive so you can gate them: Stackby: Delete Stack, Stackby: Delete Table, Stackby: Delete Column and Stackby: Delete Rows. Nothing here is recoverable through an automation, because the Developer API publishes no trash, no restore and no undelete endpoint of any kind, and the vendor's own wording for a stack is that it deletes it permanently. Whether the Stackby web interface keeps any history of its own is not addressed by the API reference, so we make no claim about it and neither should your workflow. The comfortable surface to hand an agent is the listers, the row reads and the create and update nodes. Put the deletes behind a condition or an approval task, and note that a stack delete takes every table, column, view and row inside it.

Why did my automation stop filling a column without failing?

Almost certainly a rename. Stackby keys row cells by column NAME rather than by a stable column id, and there is no name-independent write path, so renaming a column in the Stackby interface means every create and update body still carrying the old name writes nothing into that column and reports success. The fix is a habit rather than a setting: run Stackby: List Columns as a step in the workflow and build the payload from the names it returns. The mirror image is worth knowing for reads: empty cells are omitted from the field map entirely rather than returned as empty values, so a template reference to an empty cell resolves to nothing rather than raising, which is also not an error.

Is there a Stackby trigger for new or changed rows?

No. Stackby publishes no webhook and no change trigger in its Developer API, so anything event-shaped is built by polling. Stackby: New Rows In View is the closest thing: it returns the newest rows in a view, capped at 15 when no limit is set, and a schedule plus a dedupe on row id downstream is the working pattern. Its limits are real and worth designing for rather than discovering: there is no since-cursor, so a poll slower than the rate rows arrive can miss rows, which is why pairing it with Stackby: List Rows sorted by latest is the recommended backstop. There is no change feed for edits or deletes at all.

16 nodes waiting on the canvas

Put Stackby 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. Stackby is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products