Mattering Automations Tally integration
Connect Tally to Mattering Automations: forms and their block trees, questions, submissions with labelled answers, per-form analytics, workspaces and folders, organization membership, and webhook subscription management as workflow steps, authenticated with one API key.
The Mattering Automations Tally integration puts every path and method in Tally's published API on your automation canvas: forms and their block trees, questions, submissions with their answers, per-form analytics, workspaces, folders, organization membership and invitations, and webhook subscriptions with their delivery-event log. That is 38 nodes, 19 reads and 19 actions, with 6 flagged destructive.
The credential is a single Tally API key sent as a bearer token. There is no secret pair, no account id, no region and no subdomain, and no base URL to choose. Keys are created in the Tally app under Settings and then API keys. Two properties of a Tally key matter more than where it lives. It is created in the context of one user and inherits that user's permissions. And Tally documents NO SCOPES, so there is no read-only key to hand an automation: a key that can list submissions can also delete the form. Plan for that with workflow design rather than with a narrower key, because a narrower key does not exist.
One version detail is handled for you and is worth understanding anyway, because it explains a class of bug this integration cannot suffer from. 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 to whatever version was current that day, so an old key sending no header keeps receiving an old response shape indefinitely. That is how one 2025 change turned two list endpoints from bare arrays into a paginated envelope, and how an integration written against today's documentation can silently receive a different shape depending on when a customer's key was minted. Mattering sends the version header on every request, pinned to the version every sample response here was taken against.
Before you start
- A Tally account and a key created under Settings and then API keys. Tally shows the value once at creation and it cannot be retrieved afterwards.
- A decision about whose account the key belongs to, made BEFORE you create it. A Tally key inherits its creator's permissions and there are no scopes to narrow it later.
- At least one form, or the intent to create one. Tally: Create Form builds a form from a block tree on the canvas, and the verify path below reads cleanly against an account with a single form.
- An understanding that five nodes are plan-gated by Tally's own reference: Tally: Create Workspace and the four folder nodes are each marked as requiring a Pro subscription, and a free-plan key answers those with 403. No other endpoint in the reference names a plan, and Tally's pricing page does not mention the API at all, so nothing here claims the API itself is free-tier. If your account behaves otherwise, the vendor's own pages are the authority.
- For the webhook nodes, an HTTPS endpoint you already run. These nodes subscribe YOUR endpoint to Tally; Mattering does not receive Tally deliveries.
- A Mattering workspace with access to the Automations app.
Create a Tally API key
Mattering authenticates to Tally with one API key sent in the Authorization header as a bearer token. There is nothing else to configure: no host, no version to type, no second field. The only real decision is whose account creates the key, because Tally binds a key to one user and gives it that user's permissions with no scopes to trim it afterwards.
Connect Tally to Mattering
Verify it works
Open any automation canvas and check the palette for a Tally section listing the read and action nodes. Drop Tally: Get My Account onto the canvas and run a test step. It is the integration's natural probe: no parameters, no pagination, one small object with the account name, email and subscription state. It is also the only endpoint in the whole API that returns an organization id, which is what the organization nodes need, so a successful run here is what makes that family configurable.
Now check a lister, because that is where the pickers come from. Drop Tally: List Forms onto the canvas and run it. You should get your forms with their names, statuses, workspaces and submission counts, wrapped in a paginated envelope with a hasMore flag. Then drop Tally: List Submissions, open the Form field, and confirm the picker lists your forms BY NAME, grouped by status, with the submission count shown beside each. Choose one and run the step: the response returns the questions array and the submissions array side by side, which is the shape every submission workflow is built on.
One field will NOT offer a picker and that is deliberate rather than a fault: submission ids are free text everywhere they appear. A Tally submission has no human-readable name, so a dropdown would present an arbitrary page of respondent data as though it were authoritative, and beside a one-way delete that is worse than useless. Choose submission ids from an upstream read step instead. Everything in this verify path is read-only, so it cannot reach the six destructive nodes and is safe to re-run whenever you rotate the key.
Node reference
38 nodes, generated from the connector itself so this reference always matches what ships.
Read and query nodes 19
Tally: Get Form
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
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
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
tally_get_form_submission_analytics
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
tally_get_form_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
tally_get_form_visits
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
tally_get_me
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
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
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
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
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
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
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
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
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
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
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
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
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
tally_delete_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
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
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
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
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
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
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
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
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
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
tally_create_organization_invites
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
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
tally_update_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
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
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
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
tally_update_question
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
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
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.
Using the integration
On the automation canvas
Tally nodes chain with every other node. A schedule can run Tally: List Submissions with a date window and fan each row out to a Mattering database row, a Slack message, a task and another connector in one flow. A record in your CRM can drive Tally: Create Form to spin up a client-specific intake form, publish it and file it into a folder in the same run. Most of the wiring is done by pickers rather than typing: the form picker is labelled by name and grouped by status, folders depend on the workspace you chose, questions depend on the form, and the webhook event picker is grouped by delivery status because the failed group is the only one anyone retries.
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. An agent can read submissions with Tally: List Submissions, find the question losing respondents with Tally: Get Form Drop-Off, and rename it with Tally: Update Question Title. Tally publishes an official MCP server of its own, documented at api.tally.so/mcp, in beta, over HTTP with OAuth or an API key, covering form creation and updates, listing forms and submissions, and fetching submissions with filters. For an assistant that helps you build a Tally form, that is the better fit and there is no reason to avoid it. This integration is the operations side of the same product: the whole API rather than a subset, including analytics, workspaces, folders, organization membership and the webhook delivery log, running as canvas steps as well as over MCP, with the credential held once in the workspace rather than per person.
Reading submissions, and joining them to questions
Tally: List Submissions returns a form's submissions newest first with the answers inline, filtered to completed or partial, narrowed by a date range, and paged with a cursor that is the stable option for an incremental pull. Each response carries a question id, a raw answer and a formatted answer. The RAW answer is a union type: a string for text and email blocks, a number for ratings and scales, a boolean for checkboxes, an array of option ids for multi-select and ranking. 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 only its id, so it is usually the value to send onward. Responses join to questions by ID rather than by position or title, which is why the response carries the questions array beside the submissions: the join needs no second call. Map ids to titles once, with Tally: List Form Questions if you prefer a standalone lookup, and never match on question text, because Tally: Update Question Title changes the title and leaves the id alone. Each submission also carries a preview URL and a PDF URL, which hand off cleanly to a downstream step without this integration needing a binary download.
Building and editing forms, with one rule
Tally: Create Form builds a form from a block tree: a title block plus one block per question, each with its own payload shape. Create it as a draft while a workflow assembles it and published when it should start accepting submissions. The rule that governs every edit is that sending blocks REPLACES the block tree wholesale, so a block left out is removed. Read the current tree first with Tally: List Form Blocks or Tally: Get Form, change what you need, and send the whole thing back. Tally: Update Form is safe for the small stuff because every field on it is optional, so sending only a name and a status is an ordinary rename or publish; it becomes a full replacement only when you include blocks. Tally validates block payloads and rejects malformed ones outright, which is good news: a hand-built array either works or fails loudly rather than half applying.
Analytics: which nodes chart and which do not
Five analytics nodes exist and they do not return the same kind of thing. Tally: Get Form Metrics is one flat object with visits, views, starts, completions, unique respondents, the completion rate and the average visit and completion durations, so it charts most easily. Tally: Get Form Drop-Off is the one to reach for when you need ROWS: a genuine list of per-question objects with views, answers, drops and rates, which a workflow can loop over. The other three are maps rather than lists. The visits series and the submissions series are 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 will resolve to nothing and a specific value has to be named literally. Two analysis cautions apply to all of them: completion rate, answer rate and drop rate are RATIOS and the two durations are AVERAGES, so summing any of them across periods is wrong, and when a form uses conditional logic the drop-off funnel is not a simple sequence.
Workspaces, folders and people
Tally: List Workspaces returns each workspace with its members, its pending invites and its folders inline, which makes one call the cheapest way to answer who has access to what. Tally: Create Workspace, Tally: Create Folder and Tally: Update Folder handle the structure, and folders can nest, with a parent id naming the parent or sitting null at the top level. Tally: Update Folder renames only; it does not re-parent a folder. On the people side, Tally: List Organization Users and Tally: List Organization Invites cover an access review, and Tally: Invite People To Workspaces adds people. That last one carries the integration's one real idempotency trap: it SENDS EMAIL, returns no ids, and offers no dedupe key, so a retried automation run sends a second invitation to the same person. Read the invite list first and skip anyone already there.
Webhook subscriptions, honestly scoped
Tally: Create Webhook subscribes an endpoint you already run to a form's submissions, and Tally posts a submission payload the moment one lands, which is the vendor's own recommended alternative to polling under its rate limit. Be clear about the boundary: Mattering does not receive Tally deliveries, so these nodes configure Tally and do not create a trigger here. The only event type is a form response, and Tally gives a receiving endpoint 10 seconds to answer. An optional signing secret is passed straight through to Tally, which signs its outbound payloads with it so your receiver can verify them; this integration neither generates nor verifies signatures, and Tally's endpoint reference does not document the signature algorithm or header name, so nothing here claims to. The delivery log is genuinely useful: Tally: List Webhook Events carries the full payload Tally sent, the status code and body your endpoint returned, the retry count and a delivery status, and Tally: Retry Webhook Event replays one after you fix the receiver. A replay sends the same payload again, so your endpoint has to be idempotent. Tally: Update Webhook is a full replacement of the form, URL, event types and enabled flag, all of which Tally requires together, so read the current record first and send back what you are not changing.
The six destructive nodes, gated
Tally: Delete Form, Tally: Delete Submission, Tally: Delete Workspace, Tally: Delete Folder, Tally: Remove Organization User and Tally: Delete Webhook are flagged destructive, and the reason is the same in every case: the API ships no restore endpoint at all. Tally's documentation says a deleted form moves to the trash and does not say what becomes of the submissions collected on it. Its help centre says an API-deleted submission follows the same recovery window as a manual delete, but nothing in a workflow can act on that. For workspaces and folders the documentation does not state what happens to the contents, so treat both as taking their contents with them and move anything you want to keep out first. Removing a person revokes access and re-adding them means a fresh invitation they have to accept. Deleting a webhook stops deliveries immediately without queueing them, takes the delivery history with it, and a recreated subscription is a new id with no history: pause it with the enabled flag instead when the goal is temporary. Because Tally has no scopes, gating these behind conditions or approval tasks is the only control available. One delete is deliberately NOT flagged: cancelling an unaccepted invitation removes no data, and inviting the same address again restores the prior state exactly.
Rate limit, pagination and empty responses
Three operational facts shape most workflows here. Tally documents a limit of 100 requests per minute and advises webhooks over polling, and this integration does not retry internally: a rate-limit response comes back as an ordinary non-success result so the automation owns its own backoff. Pagination is NOT uniform, which is an easy way to miss records: forms take a page and a limit, workspaces take a page only with no limit parameter, webhooks take a page and a limit, the webhook delivery log takes a page only, submissions take a page and a limit alongside filters and a cursor, and folders, organization users and organization invites are not paginated at all and arrive as bare JSON arrays with no wrapper key. And several writes answer with an empty body on success, including workspace, folder and webhook updates and the invite call, so a workflow that needs the updated record must re-read it rather than templating off the write node's output.
Troubleshooting
Test Connection fails with a 401 error
A node returns 403 while other nodes work
A list node returns a shape my template cannot read
A form update removed questions I did not touch
Trying to delete a form by setting its status fails
An update succeeded but returned no data
The same person was invited twice
A workflow reading answers by question name stopped working
An analytics node returns data a workflow cannot loop over
Requests start failing during a bulk run
A webhook stopped delivering and nothing in Mattering noticed
Related
The Tally MCP
What connecting Tally 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.
Tally 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.