Menu
Mattering Automations connector

A Tally MCP that covers the whole API, not just the submissions feed

Connect one Tally API key and 38 nodes land on the canvas: read and build forms from their block trees, pull submissions with their answers already labelled, read per-form funnel and traffic analytics, manage workspaces, folders and organization membership, and administer webhook subscriptions down to their delivery log. Claude, ChatGPT and Matter can drive all of it, and so can a schedule.

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

What the Tally MCP connector does

The Tally connector for Mattering Automations is 38 nodes covering every path and method in Tally's published API document. Nineteen read and nineteen act, with six flagged destructive. This is not a submissions feed bolted onto a form product: it covers forms and their block trees, questions, submissions with their answers, per-form analytics, workspaces, folders, organization membership and invitations, and webhook subscriptions with their full delivery-event log. Tally's API has grown considerably since it launched, with analytics arriving in June 2026 and folder management shortly after, and the connector is built against the current surface rather than the original one.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any other MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can pull yesterday's submissions with Tally: List Submissions, read which question is losing people with Tally: Get Form Drop-Off, and rename that question with Tally: Update Question Title. What an assistant-only setup does not give you is the other half: the same 38 nodes are steps on an automation canvas, so a workflow runs on a schedule with nobody present and chains Tally with every other connector in your workspace in one flow.

Two Tally details shape how this connector behaves and are worth knowing before the first run. Tally versions its API by DATE and reads the pinned version from a header, and omitting that header does not mean latest: a key is bound at creation time to whatever version was current on that day, so an old key that sends no header keeps receiving an old response shape indefinitely. That is how a February 2025 change turned two list endpoints from bare arrays into a paginated envelope and how an integration built against today's documentation can silently receive a different shape depending on when the customer's key was minted. This connector sends the version header on every request, pinned to the version every sample response was taken against, so the shape is the same whichever key you connect. The second detail is about permissions rather than shapes, and it is the one to think about hardest: Tally documents no scopes at all, so a key that can read submissions can also delete the form.

Submissions are the payload most workflows exist for, so the shape is worth stating. A submission carries a flat responses array, one entry per answered question, and each entry has both a raw answer and a formatted answer. The raw answer is a union type, arriving as a string, a number, a boolean or an array of option ids depending on the block type; the formatted answer is always a display string, and for a multiple-choice question it is the option's human label where the raw answer is its id. That formatted value is usually the one a Slack message or a CRM write should use. Responses join to questions by question id rather than by position or title, which is why the submissions read returns the questions array alongside them: the join can be done in one call, and renaming a question later changes its title without changing its id.

Six nodes are flagged destructive: Tally: Delete Form, Tally: Delete Submission, Tally: Delete Workspace, Tally: Delete Folder, Tally: Remove Organization User and Tally: Delete Webhook. The classing is careful rather than blanket. Tally's documentation says a deleted form moves to the trash but does not say what becomes of the submissions collected on it, and the API ships no restore endpoint of any kind, so from a workflow's point of view every one of these is one way: anything recovered has to be recovered by a person in the Tally app. Cancelling an unaccepted invitation is deliberately NOT flagged, because no data is removed and inviting the same address again restores the prior state exactly. Five nodes are plan-gated by Tally's own documentation: Tally: Create Workspace and the four folder nodes are each marked as requiring a Pro subscription, and a free-plan key answers them with 403. Nothing else in the API reference names a plan.

One connection, three surfaces

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

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

Read and query nodes 19

Tally: Get Form

Get one form in full: its status and submission count plus the complete settings object and the block tree that defines every question, page and piece of copy. Run this before any update that sends blocks, because those updates replace the array wholesale and this is where the current one comes from.

Tally: Get Form Drop-Off

Per-question funnel for one form: views, starts, answers and drops for each block group, with an answer rate and a drop rate, plus the overall stats. This is the node that says WHICH question is losing respondents. data.data is a real list, so it charts directly. When data.hasConditionalLogic is true the funnel is not a simple sequence and the per-block rates should be read with that in mind.

Tally: Get Form Metrics

Headline numbers for one form over a period: visits, views, starts, completions, unique respondents, completion rate, and the average visit and completion durations. One flat object, which makes it the analytics node that charts most easily. Rates are ratios, so never sum them across periods.

Tally: Get Form Submissions Over Time

A submissions time series for one form, split into completed and partial per bucket, with data.interval giving the bucket width in seconds. Like the visits series, data.data is a MAP keyed by timestamp rather than a list. This counts submissions; it does not return them, which is Tally: List Submissions.

Tally: Get Form Visitor Dimensions

Where a form's visitors came from and what they used: referrer source, browser, operating system, device type, country and city, each as a count. All six are MAPS keyed by the dimension value (data.source."google.com"), not lists, so a specific value is read by naming it.

Tally: Get Form Visits Over Time

A visits time series for one form. data.interval is the bucket width in seconds, which Tally chooses from the period. Note that data.data is a MAP keyed by timestamp rather than a list, so a single bucket is read as data.data.TIMESTAMP.totalVisits; consumers that fan out over lists cannot walk it generically.

Tally: Get My Account

Retrieve the account behind the API key: name, email, subscription plan, two-factor state, and the organization id. Takes no required parameters, so it doubles as the credential health check (200 means the key works, 401 means it does not), and it is the only endpoint that returns data.organizationId, which the organization nodes need.

Tally: Get Submission

Get one submission with its answers, plus the form's questions so the answers can be labelled. Also returns a previewUrl and a pdfUrl for that submission. Note the shape differs from the list node: the submission sits under data.submission rather than in an array.

Tally: Get Workspace

Get one workspace with its members, pending invites and folders. Use it to check membership before an invite, or to read a workspace's folder tree without paging the whole list.

Tally: List Folders

List the folders in one workspace. Folders can nest: a folder's parentId names its parent, or is null at the top level. The response is a bare JSON array, so paths read data[].id with no wrapper key, and it is not paginated.

Tally: List Form Blocks

Get just a form's block tree, without the settings and counters that Tally: Get Form also returns. Use this as the read half of a read-modify-write when you are about to send blocks back through Tally: Replace Form Blocks.

Tally: List Form Questions

List a form's questions with their ids, types, titles, response counts and their underlying field uuids. This is the lookup table for reading submissions: a response carries a questionId and no title, so map ids to titles here once rather than matching on text. data.hasResponses tells you whether the form has any data at all.

Tally: List Forms

List the forms the API key can see, with each form's name, status, workspace, submission count and any payment blocks. Paginated: read data.hasMore and increment the page. This is the node every other Tally form node leans on, since it is where form ids come from.

Tally: List Organization Invites

List the invitations that have been sent and not yet accepted, with the invited address and when it was sent. The response is a bare JSON array, so paths read data[].email. Accepted invites disappear from this list; the person shows up in Tally: List Organization Users instead.

Tally: List Organization Users

List everyone in the organization, with their names, email addresses, two-factor state and subscription plan. The response is a bare JSON array, so paths read data[].email. Useful for an access review, or to check whether someone is already a member before inviting them.

Tally: List Submissions

Read a form's submissions, newest first, with the answers inline. The response returns questions and submissions side by side so you can join them without a second call: each response carries a questionId, a raw answer (a string, number, boolean or array depending on the block type) and a formattedAnswer, which is always a display string and is usually the one to send onward. Filter by completed or partial, narrow by date, or page with afterId for a stable incremental pull.

Tally: List Webhook Events

The delivery log for one webhook: every attempt with its status (QUEUED, SUCCEEDED, FAILED or DROPPED), the HTTP status code and body your endpoint returned, how many retries it has had, and the full payload Tally sent. This is how you find out what a failed delivery actually contained, and it supplies the event ids for Tally: Retry Webhook Event.

Tally: List Webhooks

List the webhook subscriptions across every form the API key can see, with each one's destination URL, form, event types, enabled state and when it last delivered. lastSyncedAt is the quickest signal that a subscription has gone quiet.

Tally: List Workspaces

List the workspaces the API key can see, each with its members, its pending invites and its folders inline. That makes this one call the cheapest way to see who has access to what. Paginated by page only; there is no limit parameter.

Action nodes 19

Tally: Cancel Organization Invite

Cancel a pending invitation so the link stops working. Not flagged destructive: the invitation has not been accepted, no data is removed, and inviting the same address again restores exactly the prior state. Returns 204 with an empty body.

Tally: Create Folder

Create a folder inside a workspace, optionally nested under an existing folder. Forms are filed into folders with the folderId field on Tally: Create Form. Reverse by deleting the folder you just created.

Tally: Create Form

Create a form from a block tree. The blocks array is the form: a FORM_TITLE block plus one block per question, each with its own payload shape. Create it as DRAFT while you build it and PUBLISHED when it should start accepting submissions. Reverse by deleting the form you just created.

Tally: Create Webhook

Subscribe an HTTP endpoint of yours to a form's submissions. Tally posts a FORM_RESPONSE payload the moment a submission lands, which is the vendor's recommended alternative to polling under the 100-requests-per-minute limit. The URL must be an endpoint you already run: Mattering does not receive Tally webhook deliveries, so this node configures Tally, it does not create a trigger here. Reverse by deleting the webhook.

Tally: Create Workspace

Create a workspace to group forms and the people who can see them. The response carries the new workspace's id, which the folder and invite nodes need. Reverse by deleting the workspace you just created.

Tally: Delete Folder

DESTRUCTIVE. Delete a folder from a workspace. Tally's documentation does not state what happens to the forms filed in it or to any folders nested beneath it, and there is no restore endpoint, so move anything you want to keep out first. Returns 204 with an empty body.

Tally: Delete Form

DESTRUCTIVE. Delete a form. Tally's documentation says this moves the form to the trash, and it does not document what becomes of the submissions collected on it. There is no restore endpoint in the API, so from an automation's point of view this is one way: anything recovered has to be recovered by a person in the Tally app, within whatever retention window that account has. Returns 204 with an empty body.

Tally: Delete Submission

DESTRUCTIVE. Delete one submission and the answers it contains. Tally's help centre says a submission deleted through the API goes to the trash and follows the same recovery window as a manual delete, but the API ships no restore endpoint, so nothing in a workflow can undo this. Returns 204 with an empty body.

Tally: Delete Webhook

DESTRUCTIVE. Delete a webhook subscription. Deliveries stop immediately and are not queued, so every submission that arrives afterwards is never sent anywhere; the subscription's delivery-event history goes with it, and recreating it produces a new id with no history. If you only want to stop deliveries for a while, set isEnabled false with Tally: Update Webhook instead. Returns 204 with an empty body.

Tally: Delete Workspace

DESTRUCTIVE. Delete a workspace. Tally's API documentation does not state what happens to the forms, folders and submissions inside it, and ships no restore endpoint, so treat it as taking its contents with it. Move anything you want to keep to another workspace first. Returns 204 with an empty body.

Tally: Invite People To Workspaces

Invite one or more people to one or more workspaces. Someone who is already in the organization is added to those workspaces directly; anyone else is emailed an invitation. THIS SENDS EMAIL, so re-running it on a retry can send a second invitation: guard it with a check against Tally: List Organization Invites. Returns 204 with an empty body, so read the invite list afterwards if you need the new ids.

Tally: Remove Organization User

DESTRUCTIVE. Remove a person from the organization, revoking their access to its workspaces and forms. Tally's documentation does not state what happens to the forms they created, and there is no undo endpoint: re-adding them means a fresh invitation they have to accept. Returns 204 with an empty body.

Tally: Replace Form Blocks

Replace a form's block tree in one call, optionally with its settings. FULL REPLACEMENT: the array you send becomes the whole form, so a block left out is removed. Read the current tree with Tally: List Form Blocks, change what you need, and send the whole thing back. Tally validates block payloads and rejects malformed ones, so a bad array fails loudly rather than half-applying.

Tally: Retry Webhook Event

Re-send one webhook delivery to its destination URL. Use it to replay a FAILED event after fixing the receiver. Your endpoint will see the same payload again, so it needs to be idempotent: a retried submission must not create a second record on your side.

Tally: Update Folder

Rename a folder. Only the name can be changed here: this endpoint does not re-parent a folder. Returns 204 with an empty body.

Tally: Update Form

Change a form: rename it, publish or unpublish it, replace its blocks, or edit its settings. Every field is optional, so sending only name and status is a safe rename. Sending blocks is NOT safe in the same way: that array replaces the form's entire block tree, so read the current blocks with Tally: Get Form first and send them back modified.

Tally: Update Question Title

Rename one question. This changes the label reporting and exports show for that question; it does not touch the question's type, its options or the answers already collected. Reverse it by sending the old title back.

Tally: Update Webhook

Change a webhook: point it at a different URL, move it to another form, or pause it by setting isEnabled false. FULL REPLACEMENT of the four core fields: formId, url, eventTypes and isEnabled are all required together, so read the current record with Tally: List Webhooks and send back the values you are not changing. Returns 204 with an empty body. Pausing is the reversible way to stop deliveries; deleting is not.

Tally: Update Workspace

Rename a workspace. Returns 204 with an empty body, so a workflow that needs the updated record must re-read it with Tally: Get Workspace.

Connecting Tally takes one credential

One field, one key, no secret pair, no account id, no region and no subdomain. Tally keys are created in the Tally app under Settings and then API keys. Two properties of a Tally key matter more than where it comes from. First, Tally documents that a key can only be created in the context of your own user and that it inherits that user's permissions, so the key reaches exactly what the person who made it can reach. Second, Tally documents no scopes, which means there is no read-only Tally key to hand an automation: a key that can list submissions can also delete a form, a workspace or a person's access. That is worth designing around rather than discovering, and it is the reason the destructive nodes on this connector are worth gating even for a workflow that only intends to read. The key is shown once at creation and cannot be retrieved again. The connector also sends Tally's dated version header on every request, pinned to the version its sample responses were taken against, which is what stops the response shape depending on when your key happened to be minted.

1

Open Tally, go to Settings and then API keys, and create a key. Copy the value while it is on screen: Tally shows it once.

2

Decide whose account it belongs to before you create it, because a Tally key inherits that user's permissions and there are no scopes to narrow it afterwards.

3

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

4

Click Test Connection. Mattering calls Tally's account endpoint, which needs no parameters and no ids, so it proves the key on its own. An invalid key answers 401.

5

All 38 Tally nodes appear in the canvas palette. Run Tally: List Forms first: it is where every form id comes from, and it is the source of the form picker that most of the other nodes use.

Common uses for the Tally MCP

Route submissions the moment they are worth routing

Tally: List Submissions reads a form's submissions newest first with the answers inline, filtered to completed or partial, narrowed by date, and paged with a stable cursor for an incremental pull. Because it returns the questions array beside the submissions, a workflow can label answers without a second call. Each response carries a formatted answer that is always a display string, which is what a Slack message, an email or a CRM write should generally use rather than the raw value. From there it is ordinary canvas work: a condition on one answer decides whether a human sees it, a Mattering database row records it, and another connector writes it wherever it belongs.

Find out which question is costing you completions

Tally: Get Form Drop-Off is the analytics node most worth scheduling. It returns a per-question funnel with views, starts, answers and drops for each block group plus an answer rate and a drop rate, and unlike the other analytics nodes it returns a genuine list, so it charts directly and can be walked in a workflow. Tally: Get Form Metrics adds the headline numbers over a period: visits, views, starts, completions, unique respondents, completion rate and the average visit and completion durations. Two cautions belong with any workflow built on these: the rates are ratios and the durations are averages, so summing either across periods is confidently wrong, and when a form has conditional logic the funnel is not a simple sequence and the per-block rates should be read with that in mind.

Build and edit forms from a workflow instead of by hand

Tally: Create Form builds a form from a block tree, and Tally: Update Form and Tally: Replace Form Blocks change one that exists. This is the half people do not expect a form API to have, and it opens up templating: create a client intake form from a record in your CRM, publish it, and file it into the right workspace folder in the same run. Create it as a draft while the workflow assembles it and published when it should start accepting submissions. One rule governs all of it and the nodes say so loudly: sending blocks is a FULL REPLACEMENT, so a block left out is removed. Read the current tree with Tally: List Form Blocks or Tally: Get Form, change what you need, and send the whole thing back. Tally validates block payloads and rejects malformed ones, so a bad array fails loudly rather than half applying.

Keep the workspace tidy without anyone tidying it

Tally: List Workspaces returns each workspace with its members, pending invites and folders inline, which makes one call the cheapest way to see who has access to what. Tally: Create Workspace, Tally: Create Folder and Tally: Update Folder handle the structure, and Tally: List Organization Users and Tally: List Organization Invites cover an access review. Tally: Invite People To Workspaces adds people, and it carries the one idempotency trap in the connector: it SENDS EMAIL, returns no ids, and offers no dedupe key, so a retried automation run sends a second invitation. Guard it with a read of the invite list first, which is exactly what the node description tells you to do.

Administer webhook subscriptions and see what actually delivered

Tally: Create Webhook subscribes an endpoint you already run to a form's submissions, and Tally: Update Webhook, Tally: Delete Webhook, Tally: List Webhooks and Tally: List Webhook Events manage them. The delivery log is the reason this family earns its place: it carries the full payload Tally sent, the status code and body your endpoint returned, the retry count and a delivery status, so a failed delivery can be inspected rather than guessed at, and Tally: Retry Webhook Event replays one after you fix the receiver. Two honest boundaries. These nodes configure Tally to call YOUR endpoint; Mattering does not receive Tally deliveries, so this is subscription management rather than a trigger here. And a replayed delivery sends the same payload again, so your receiver has to be idempotent.

Reporting that does not fight the rate limit

Tally documents a limit of 100 requests per minute and its own advice is to prefer webhooks over polling. That shapes how a reporting workflow should be built: pull a page of submissions with a date window rather than fetching each one by id, take the questions array from the same response instead of a second lookup, and let a schedule rather than a loop set the pace. Tally: List Form Questions is the lookup table to cache once, because a response carries a question id and no title, and mapping ids to titles once beats matching on text that somebody may rename tomorrow.

Example: A daily intake run that labels answers, files the record and watches its own plumbing

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 each morning.

2

Tally: List Submissions reads the form with the date window set to the previous day and the filter set to completed submissions, returning the answers and the questions array in one call.

3

A condition ends the run when nothing came in, which keeps the request count low against Tally's 100 per minute limit.

4

For each submission, the formatted answer on each response supplies display-ready values, and the question id supplies the stable key, so the workflow maps fields by id rather than by question text that somebody may rename.

5

A Mattering database row is written keyed on the submission id, and a task opens for whoever owns follow-up. The submission's preview and PDF URLs ride along on the row, so nobody has to go back into Tally to see the original.

6

On a weekly schedule, Tally: Get Form Drop-Off reads the per-question funnel into a database and a task opens when a question's drop rate moves beyond a threshold you set, which turns a form problem into somebody's queue rather than a quarterly discovery.

7

Also weekly, Tally: List Webhooks is checked for a subscription whose last delivery timestamp has gone quiet, and Tally: List Webhook Events is read for failures, so a broken receiver is noticed by the workflow instead of by a customer.

Tally MCP questions, answered

What Tally operations are supported?

38 nodes, one per path and method in Tally's published API document, split 19 read and 19 action. Forms: list, get, create, update, list blocks, replace blocks, delete. Questions: list, and rename one. Submissions: list with filters and a date window, get one, delete one. Analytics: headline metrics, a visits series, a submissions series, visitor dimensions and a per-question drop-off funnel. Workspaces and folders: list, get, create, rename and delete. Organization: list users, list invites, invite people, cancel an invite, remove a user. Webhooks: list, create, update, delete, list delivery events and retry one. Deliberately not built: an inbound trigger, because nothing in Mattering receives Tally deliveries today; per-block typed configuration, because the block vocabulary runs to dozens of types with their own payloads and Tally validates them server side anyway; and a file-download node, because file answers arrive as URLs that hand off cleanly to a worker.

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. The same nodes are also steps on the automation canvas, which is the part that matters most for a form product: submissions arrive when they arrive, and the workflow that handles them should not need somebody sitting in a chat window.

Tally publishes its own MCP server. Why use this connector?

It does, and it is worth naming plainly rather than working around. Tally documents an official MCP server at api.tally.so/mcp, in beta, over HTTP with OAuth or an API key, and it covers building and updating forms, listing forms and submissions, and fetching submissions with filters. If you want an assistant that helps you make a Tally form, use it. This connector answers a different question. It covers the whole API rather than a curated subset, including analytics, workspaces, folders, organization membership and the webhook delivery log. It runs those operations as canvas steps as well as over MCP, so they fire on a schedule with nobody present. It chains Tally with every other connector in one workflow. And it holds the credential once in a shared workspace store rather than in each person's client config, with destructive nodes flagged so you can gate them.

Can Tally submissions trigger a Mattering automation directly?

Not through this connector, and it is better to say so than to let the wording imply otherwise. The six webhook nodes create, list, update, delete, inspect and retry Tally webhook SUBSCRIPTIONS, and the URL you give them must be an endpoint you already run: Mattering does not receive Tally webhook deliveries today, so this is subscription management rather than an inbound trigger. What works instead is a schedule with Tally: List Submissions, using a date window or the submission cursor for an incremental pull. Tally's own advice is to prefer webhooks over polling given its 100 requests per minute limit, so keep the schedule modest and the window tight rather than fetching each submission individually.

Can an AI agent delete a form or a submission?

It can, which is why the six destructive nodes are flagged: Tally: Delete Form, Tally: Delete Submission, Tally: Delete Workspace, Tally: Delete Folder, Tally: Remove Organization User and Tally: Delete Webhook. The recovery position is worth reading exactly. Tally's documentation says a deleted form moves to the trash and does not say what happens to the submissions collected on it, and the API ships no restore endpoint at all, so nothing in a workflow can undo any of these: recovery, where it exists, is a person in the Tally app within whatever window that account has. Deleting a workspace or a folder is documented even less specifically, so treat both as taking their contents. One fact compounds all of it: Tally has no scopes, so any automation holding a working key can reach every one of these nodes. Gate them behind conditions or approval tasks rather than relying on a narrower key, because there is no narrower key to create.

How do I match an answer to the question that was asked?

By question id, never by position and never by title. A response carries a question id, a raw answer and a formatted answer, and nothing in the payload is keyed by the question's human text, which is deliberate on Tally's part: renaming a question through Tally: Update Question Title changes the title and leaves the id alone. The submissions read returns the questions array alongside the submissions so the join can be done in one call, and Tally: List Form Questions is the standalone lookup table when you want to map ids once and cache them. A workflow that matches on text is a workflow that breaks the first time somebody edits the wording.

Why does an analytics node return something a workflow cannot loop over?

Because three of the five return maps rather than lists, and it is better to know which is which than to debug it. The visits series and the submissions series come back keyed by timestamp, and the visitor dimensions come back as six maps keyed by the dimension value, so a path that fans out over a list resolves to nothing against any of them and a specific value has to be named literally. Tally: Get Form Metrics is a single flat object, which charts easily. Tally: Get Form Drop-Off is the analytics node to reach for when you need rows: its data is a genuine list of per-question objects with views, answers, drops and rates. And whichever you use, do not sum a rate or an average across periods.

Why does an update node return nothing?

Because several Tally writes answer with an empty body by design, which is documented behaviour rather than a dropped response. Updating a workspace, a folder or a webhook, and inviting people, all return a bare success with no content, so a workflow that expects the updated record back must re-read it with the matching get or list node. The related trap is the invitation one: it returns no ids AND sends email, with no dedupe key, so a retried run sends a second invitation. Check Tally: List Organization Invites before inviting rather than after.

Does pagination work the same way across the connector?

No, and assuming it does is one of the easier ways to build a workflow that misses records. Forms take a page and a limit. Workspaces take a page only, with no limit parameter at all. Webhooks take a page and a limit with their own default. The webhook delivery log takes a page only. Submissions take a page and a limit alongside their filters and a cursor. And folders, organization users and organization invites are not paginated at all, arriving as bare JSON arrays with no wrapper key, so their paths read differently from the paginated ones. Each node's description states its own shape, and it is worth checking rather than copying a path from a neighbouring node.

38 nodes waiting on the canvas

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

Start Free Explore our Products