Menu

Mattering Automations Fillout integration

Connect Fillout to Mattering Automations: list forms, read a form's questions and field metadata, list and fetch submissions with their answers, import submissions, delete one, and manage webhook subscriptions as workflow steps, authenticated with one API key.

The Mattering Automations Fillout integration puts every operation Fillout publishes on your automation canvas: list forms, read one form's questions and field metadata, list a form's submissions with filters and a date range, fetch one submission, import up to ten submissions, delete one, and create or delete a webhook subscription. That is 8 nodes, 4 reads and 4 actions, with 2 flagged destructive, and the number is the whole API rather than a subset of it.

It is worth reading the boundary as carefully as the coverage, because a form product invites assumptions the API does not support. Fillout's REST API is a submissions API with a READ-ONLY view of form structure. Forms are built in Fillout's editor and cannot be created, changed or deleted over the wire, and there is no question or field editing. There is no submission update, only create and delete. There are no analytics or reporting endpoints, no workspaces, folders or team management, and no way to list, read, update or replay a webhook after it exists. Each of those is an absence in the vendor's API rather than a gap here.

The credential is one API key, generated in the Fillout app under Settings and then Developer. Fillout documents no scopes, so a single key does everything this integration does, deletes included. One extra field sits beside the key and it is easy to miss: the API base URL is a property of the ACCOUNT, not a constant. The default deployment answers at Fillout's primary host, the EU agent answers at its own, and a self-hosted installation answers at whatever address that account's API dashboard shows. A Fillout key is issued by one deployment and does not work against another, so the host lives on the credential. That is what keeps the form picker on six of the eight nodes working correctly for EU and self-hosted accounts without any extra configuration.

Before you start

  • A Fillout account and an API key generated under Settings and then Developer. The key can be revoked or regenerated in the same place.
  • Your account's API base URL, which the API dashboard shows. Default accounts need nothing here. EU agent and self-hosted accounts have their own address, and a key from one deployment does not work against another.
  • At least one form that already exists in Fillout. The API cannot create one, so form building is a human step in the editor and every node except the form lister needs a form id.
  • For a Gate-style walkthrough of the write nodes, one form with at least one submission and a throwaway HTTPS endpoint to point a test webhook at.
  • No plan claim is made in this guide. Nothing in Fillout's API documentation gates any of these eight endpoints by plan, and this guide names no tiers, prices or quotas; Fillout's own pricing page is the authority on what your account includes.
  • A Mattering workspace with access to the Automations app.

Generate a Fillout API key

Mattering authenticates to Fillout with one API key sent in the Authorization header as a bearer token. There is no version header, no account id and no signature to compute. The only decision beyond generating the key is whether your account sits on Fillout's default deployment or on the EU agent or a self-hosted installation, because that decides the base URL the key belongs to.

Sign in to Fillout and open Settings, then Developer.
Generate an API key and copy the value.
On the same page, note the API base URL shown for your account. On a default account this is Fillout's standard host and you can leave the override blank in Mattering.
Fillout documents no scopes and no per-key permissions, so this key does everything the API can do, including deleting submissions. There is no read-only key to create instead, which is why the destructive nodes are worth gating even in a workflow that only intends to read. Regenerating the key from this page invalidates the old one immediately, so update the Mattering credential in the same sitting.
A Fillout key is issued by ONE deployment. A key from the default host will not authenticate against the EU host and the reverse is equally true, so a key and its base URL travel together.

Connect Fillout to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Fillout from the list.
Click Create new credential and paste the API key. Set the region or the base URL override only if your account is on the EU agent or self-hosted, then save.
The key is stored encrypted in Google Secret Manager and never appears in workflow logs. The base URL is not a secret and is stored as an ordinary field.
Click Test Connection. Mattering calls Fillout's form list, which is the only endpoint in the API with no path parameters and no query parameters, so it proves the key and the host together in one request without needing a form id first.
Click Connect. All 8 Fillout nodes appear in your canvas palette.

Verify it works

Open any automation canvas and check the palette for a Fillout section listing the read and action nodes. Drop Fillout: List Forms onto the canvas and run a test step. It is the integration's natural probe: no parameters, no pagination, an array of name and form id pairs. Note the shape while you are here, because it is the only bare array in the API: paths read data[].formId with no wrapper key. Every other node needs a form id, and this is where it comes from.

Now read a form's structure. Drop Fillout: Get Form Metadata onto the canvas, open the Form field, and confirm the picker lists your forms BY NAME with the id shown underneath. The id repeats as the second line on purpose: Fillout does not stop two forms sharing a name and a form summary carries only two properties, so the id is the only disambiguator that exists. Run the step and you get the questions with their ids, titles and types, plus any calculations, URL parameters, Fillout Scheduling fields, Fillout Payments fields and quiz configuration.

Finish with real submissions, and set two fields deliberately while you do. Drop Fillout: List Submissions onto the canvas, choose the same form, set Sort to descending and raise Limit toward the vendor cap of 150. Fillout's sort defaults to ASCENDING, so leaving it alone returns the oldest rows rather than the newest, which reads as a working step returning the wrong data. The response carries the rows under a responses key with a total count and a page count beside them, and each row carries a submission id, a submission time and a flat questions array where every entry holds the question's id, its text as a name, its type and the answer as a value. Everything in this verify path is read-only, so it cannot reach either destructive node and is safe to re-run whenever you rotate the key.

Node reference

8 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 4

Fillout: Get Form Metadata

fillout_get_form_metadata

Describe one form: its questions with their ids, titles and types, plus any calculations, URL parameters, Fillout Scheduling fields, Fillout Payments fields and quiz configuration. This is the lookup table for both reading and writing submissions, because an answer is addressed by question id. The type tells you what an answer value will look like; the documented types are: Address, AudioRecording, Calcom, Calendly, Captcha, Checkbox, Checkboxes, ColorPicker, CurrencyInput, DatePicker, DateRange, DateTimePicker, Dropdown, EmailInput, FileUpload, ImagePicker, LocationCoordinates, LongAnswer, Matrix, MultiSelect, MultipleChoice, NumberInput, OpinionScale, Password, Payment, PhoneNumber, Ranking, RecordPicker, ShortAnswer, Signature, Slider, StarRating, Subform, SubmissionPicker, Switch, Table, TimePicker, URLInput. Fillout adds new types regularly and advises discarding unknown ones, so branch on type with a default case.

Fillout: Get Submission

fillout_get_submission

Get one submission by its id, with the same answer shape the list node returns. Note the wrapper differs: the row sits under data.submission rather than inside an array, so a workflow written against the list node needs its paths adjusted.

Fillout: List Forms

fillout_list_forms

List every form the API key can see, as an array of name and formId pairs. Takes no parameters and is not paginated, so it doubles as the credential health check (200 means the key works and reaches the right host, 401 means it does not). This is where form ids come from: every other Fillout node needs one. Note the response is a bare JSON array, so paths read data[].formId with no wrapper key.

Fillout: List Submissions

fillout_list_submissions

Read a form's submissions with the answers inline. Each row carries a submissionId, a submissionTime and a flat questions array where every entry holds the question's id, its text as name, its type and the answer as value. Filter by date range, search for submissions containing a piece of text, include unfinished (in_progress) submissions, and page with limit and offset against data.totalResponses and data.pageCount. The list key is responses, not submissions.

Action nodes 4

Fillout: Create Submissions

fillout_create_submissions

Import up to 10 submissions into a form in one call. Answers are addressed by question id, so read the ids from Fillout: Get Form Metadata first. Imported rows appear in the form's Results tab and come back with their new submissionIds, which is what makes this reversible: delete them to undo. Fillout states that submissions created through the API do NOT trigger email notifications, workflows or integrations, so this is a backfill and migration tool rather than a way to fire a form's downstream automations.

Fillout: Create Webhook

fillout_create_webhook

Subscribe a URL to a form's submissions. Fillout then posts each new submission to that URL in the same shape as an entry in the responses list from Fillout: List Submissions. The response is just the new webhook's numeric id, and there is no endpoint that lists webhooks afterwards, so store that id if you ever intend to remove the subscription. Reverse by deleting the webhook you just created. This node configures Fillout to call an endpoint YOU run: Mattering does not receive Fillout deliveries.

Fillout: Delete Submission

fillout_delete_submission

DESTRUCTIVE. Delete one submission and every answer it contains. Fillout documents no restore endpoint and no recovery window for a submission deleted through the API, so nothing in a workflow can undo this. Returns 200 with no documented response body.

Fillout: Delete Webhook

fillout_delete_webhook

DESTRUCTIVE. Remove a webhook subscription so Fillout stops delivering that form's submissions. Fillout publishes no endpoint that lists webhooks and no delivery log or replay, so once a subscription is gone there is no way to enumerate what was removed, and every submission made between the removal and any re-subscribe is never delivered and cannot be re-sent. Recreating a webhook for the same form and URL issues a NEW id. Note the method is POST rather than DELETE: the id travels in the JSON body.

Using the integration

On the automation canvas

Fillout nodes chain with every other node. A schedule can run Fillout: 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 migration can read rows from a spreadsheet or another form tool and load them with Fillout: Create Submissions. The form field on six of the eight nodes is a picker sourced from Fillout: List Forms, so form ids are chosen rather than typed. Submission ids are chosen differently: Fillout: Get Submission offers a picker labelled by submission time with a text search behind it, while Fillout: Delete Submission deliberately leaves the same field as free text, because a browsable dropdown of real respondent data beside a one-way delete invites exactly the mistake that cannot be undone.

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 four read nodes are a comfortable set to hand an agent, and Fillout's payload helps here: because each answer carries the question's TEXT alongside its id, an assistant can summarise last week's responses or count how many people chose an option without anyone first explaining the form's structure to it. Fillout does not publish an MCP server of its own, so there is no vendor server to weigh this against: its documentation index carries no MCP page and no MCP reference. Keep the two destructive nodes out of an agent's reach or behind an approval step, since Fillout has no scopes and therefore no read-only key to hand out instead.

Reading submissions, and the defaults to set deliberately

Fillout: List Submissions is the node most workflows are built on, and four of its defaults deserve a decision rather than acceptance. SORT defaults to ascending, meaning oldest first, so a latest-submissions workflow that does not set it to descending reads the wrong rows and looks like it worked. STATUS defaults to finished, so unfinished fills are invisible until you ask for the in-progress status, and those rows can still change after you read them. PREVIEW submissions, the ones filled while testing the form in the editor, are excluded unless you ask for them, which is right for reporting and confusing while testing. And LIMIT defaults to 50 against a vendor cap of 150, with offset-based paging and a total count and page count in the response to tell you when to stop. Prefer one list call with a raised limit over a loop of single fetches, because Fillout's rate limit is tight.

The answer shape, and what is safe to template

Each submission carries a flat questions array where every entry holds the question's id, its text as a name, its type and the answer as a value. That is friendlier than most form APIs, because the question text rides along with the answer and a downstream step can address a field by the name people recognise. The VALUE is a union whose shape follows the question type: a string for short answer, email and multiple choice, a number for star rating, number input and slider, a boolean for switch and checkbox, and an array for multi-select, checkboxes and ranking. Structured types are the caveat: Address, Matrix, Table, File Upload, Signature, Payment and Subform return objects or arrays of objects whose members Fillout's specification does not enumerate, so inspect one real submission before templating a path into one rather than guessing at it. Four sibling arrays ARE fully specified and safe to build on: calculations, URL parameters captured at fill time, Fillout Scheduling bookings with their event times and reschedule links, and Fillout Payments records. Two conversions catch people out: a calculation's value arrives as TEXT even when the calculation's own type is a number, so cast before arithmetic, and a payment amount is in CENTS.

Reading form structure before you read answers

This is the lookup table for both reading and writing, because an imported answer is addressed by question id rather than by name. It returns the questions with their ids, titles and types, plus any calculations, URL parameters, Fillout Scheduling fields, Fillout Payments fields and quiz configuration. The type field is what tells a workflow what an answer will look like, and Fillout's own advice belongs in any workflow that branches on it: Fillout adds new question types regularly and asks that applications discard fields with unknown types, so write a default case rather than an exhaustive list that will quietly age out. Note that the shape here differs from the form lister: this is an object with a questions array, where the lister is a bare array of two-field summaries.

Importing submissions, and why they are inert

Fillout: Create Submissions imports up to ten submissions per call, addressed by question id, and returns their new submission ids, which is what makes it reversible: deleting those ids restores the prior state exactly. It is the node for a migration off another form tool or a backfill of historical records. One property must be built into the design rather than discovered afterwards. Fillout states that submissions created through the API do NOT trigger email notifications, workflows or integrations, so an imported row is inert: a workflow that imports a record expecting the form's own downstream automation to fire will silently do nothing at all. If a notification or a downstream write is wanted, put it in the same Mattering workflow beside the import. The ten-per-call cap comes from the request schema rather than from a plan, so a larger migration is chunked, and each chunk costs a request against the rate limit.

Webhook subscriptions, honestly scoped

Fillout: Create Webhook subscribes a URL you already run to a form's submissions, and Fillout then posts each new submission to it in the same shape as a row from the submissions list, so that node's output doubles as the payload reference. Fillout: Delete Webhook removes the subscription, and note that Fillout uses a POST for it with the id in the body rather than a DELETE. Four boundaries belong in the design. Mattering does not receive Fillout deliveries, so these nodes configure Fillout and do not create a trigger here. Fillout documents no signing secret and no signature header for these subscriptions, so a receiver cannot verify authenticity beyond keeping the URL unguessable, which is a real difference from some other form tools. There is NO webhook lister, so the id returned by the create node is the only record that the subscription exists: store it if you ever intend to remove the subscription. And Fillout's in-app Webhook integration, configured per form in the editor with its own body, headers and parameters, is a DIFFERENT mechanism that this API can neither see nor manage, so do not expect one to show the other.

The two destructive nodes, gated

Fillout: Delete Submission removes one submission and every answer in it. Fillout documents no restore endpoint and no recovery window for a submission deleted through the API, so nothing in a workflow can undo it. Fillout: Delete Webhook is worse than it looks for reasons that are absences rather than behaviours: with no webhook lister there is no way to enumerate what was removed after the fact, and with no delivery log and no replay, every submission made between the removal and any re-subscribe is never delivered and cannot be re-sent. Recreating a webhook for the same form and URL issues a NEW id. Because Fillout has no scopes, gating is the only control available: put both behind a condition or an approval task, keep them out of an agent's reach, and note that the submission id on the delete node is free text by design so the id has to come from a step that chose it deliberately. Fillout: Create Submissions is not flagged destructive, because it adds rows, returns their ids, and is undone by deleting them.

Rate limits, paging and response shapes

Fillout documents a limit of 5 requests per second per account and API key, applying to every endpoint. That is tight enough to shape design: a loop calling Fillout: Get Submission once per row against a form of any size will trip it, so prefer Fillout: List Submissions with the limit raised toward 150 and page with the offset. This integration does not retry internally, so a rate-limit response surfaces as an ordinary non-success result and the backoff belongs in the workflow. Response shapes differ per endpoint more than you would expect from an eight-operation API, and copying a path between nodes is the usual cause of a template that resolves to nothing: the form lister returns a BARE array, form metadata returns an object with a questions array, the submissions lister returns rows under a responses key with a total and a page count, a single fetch returns the row under a submission key, and an import returns the new rows under a submissions key. Three list-ish endpoints, three different keys.

Troubleshooting

Test Connection fails with a 401 or 403 error
The key is the likely problem rather than the path, since the probe endpoint takes no parameters at all. Check for whitespace picked up in the copy, and confirm the key still exists under Settings and then Developer in Fillout, since regenerating a key there invalidates the previous one immediately. If the key is definitely current, check the deployment next: a Fillout key is issued by one deployment and does not authenticate against another, so a key from the EU agent or a self-hosted installation used against the default host fails here in exactly this way. The base URL your account's API dashboard shows is the one the credential needs.
Test Connection fails with a 404 instead of an auth error
A 404 rather than a 401 points at the base URL rather than the key. The most common cause on a custom base URL override is a path prefix that does not match what Fillout expects, so paste the address exactly as the API dashboard shows it rather than reconstructing it. Trailing slashes and an added path segment are the usual culprits. If your account is on the default deployment, leave the override blank entirely and let the integration use the standard host.
A latest-submissions workflow returned the oldest records
Fillout's sort parameter defaults to ASCENDING, meaning oldest first, and this failure is silent: the step returns rows, succeeds and processes the wrong ones. Set Sort explicitly to descending on Fillout: List Submissions whenever you mean the newest. While you are in that node, check the two other defaults that hide records: unfinished fills are excluded until you ask for the in-progress status, and submissions filled while previewing the form in the editor are excluded until you ask for them, which is the usual reason a test submission cannot be found.
A submission I just filled while testing does not appear
If you filled it from the form editor's preview, it is a preview submission and those are excluded by default. Turn on the include-preview option on Fillout: List Submissions to see it. If you filled it from the live form but did not finish, it is an in-progress submission and the status filter defaults to finished, so ask for the in-progress status instead. Note that an in-progress row is a live record the respondent can still change after you read it, so treat it as provisional rather than final.
An imported submission did not trigger the form's notifications or integrations
That is documented behaviour rather than a fault. Fillout states that submissions created through the API do not trigger email notifications, workflows or integrations, which makes Fillout: Create Submissions a backfill and migration tool rather than a way to fire a form's downstream automation. Build the notification or the downstream write into the same Mattering workflow, beside the import, using the other nodes on the canvas. If the import itself failed rather than being inert, check the batch size: the request schema caps it at ten submissions per call, so larger batches must be chunked.
A template reading answers resolves to nothing
Check which node produced the data, because three endpoints use three different keys. The submissions lister returns rows under a responses key, a single fetch returns its row under a submission key, and an import returns its new rows under a submissions key, so a path copied from one node will not resolve against another. The form lister is a fourth shape again, the only bare array in the API, so its paths read data[].formId with no wrapper key at all. If the path is right but a specific ANSWER resolves to nothing, the question type is the next thing to check: structured types like Address, Matrix, Table, File Upload, Signature, Payment and Subform return objects whose members Fillout's specification does not enumerate, so inspect one real submission rather than guessing at the inner path.
Arithmetic on a calculation or a payment amount gives the wrong answer
Two type conversions cause almost all of these. A calculation's value arrives as TEXT even when the calculation's own type is a number, so cast it before any arithmetic rather than assuming a numeric type. And a payment's total amount is in CENTS, so it needs dividing before anything displays it as a currency figure. Both are the vendor's shapes rather than a conversion this integration performs, which is why the samples show them as they arrive.
A workflow branching on question type stopped handling some answers
Fillout adds new question types regularly and its own guidance is that an application should discard fields with unknown types. A branch built from an exhaustive list of the types that existed when it was written will quietly stop matching when a new one appears in a form. Add a default case that logs or skips the unknown type rather than failing, and use Fillout: Get Form Metadata to see the types a specific form actually uses when you need to extend the branch.
Requests start failing during a bulk run
Check the request rate against Fillout's documented limit of 5 requests per second per account and API key. That ceiling is low enough that a fan-out fetching each submission individually will trip it on a form of any size. Replace the loop with a single Fillout: List Submissions call with the limit raised toward the vendor cap of 150 and page with the offset, and pace an import in chunks of ten rather than firing them in parallel. This integration does not retry internally, so a rate-limit response comes back as an ordinary non-success result and the backoff belongs in the workflow as a delay step or a smaller schedule.
A webhook was created but I cannot find it again
Fillout publishes no endpoint that lists webhooks, so the numeric id returned by Fillout: Create Webhook is the only record that the subscription exists. Store it at creation time, for instance in a Mattering database row keyed on the form, or Fillout: Delete Webhook has no id to work with later. If the id was lost, the subscription keeps delivering and cannot be removed through the API. Note also that Fillout's in-app Webhook integration, configured per form in the editor, is a separate mechanism this API cannot see, so a subscription created here will not appear there and the reverse is equally true.
Deleting a webhook is rejected by the id
The create call returns the new webhook's id as an INTEGER while the delete call documents its id parameter as a string, so the round trip crosses a type boundary. Templating the created id through resolves it to text, which is the intended path and what the node's description recommends. If the value was stored elsewhere and is being sent as a raw number, send it as text instead. Note also that the delete uses a POST with the id in the JSON body rather than a DELETE method, which is Fillout's shape rather than an inconsistency here.

Fillout 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