Mattering Automations Wufoo integration
Connect Wufoo to Mattering Automations: forms, field maps, entries, entry counts, comments, saved reports and account users as workflow steps, plus submitting an entry and managing a form's webhook, authenticated with your Wufoo subdomain and API key.
The Mattering Automations Wufoo integration puts Wufoo API v3 on your automation canvas: list the forms an API key can see, read a form's settings and its field map, pull entries and entry counts, read the comments a team left on entries, work with saved reports, their fields, their entries and their widgets, list the users on the account, submit an entry to a form, and add or remove a form's webhook. Seventeen nodes in total, fourteen that read and three that act.
Wufoo, now part of SurveyMonkey, is a form builder, and its v3 API is a read surface with three writes. Forms are built in the Wufoo editor and this integration reads them and feeds them: there is no form create, update or delete, no question editing, no entry update or delete, no comment write, and no report management. Knowing that up front is worth more than discovering it halfway through a build, so the sections below say plainly what is not there as well as what is.
One property of the API shapes everything you will build. Wufoo entries are keyed by opaque field ids such as Field105 and carry no question text at all, so a form's field map is a hard dependency rather than an optional extra: Wufoo: List Forms gives you a form hash, Wufoo: List Form Fields gives you the id to title map, and Wufoo: List Form Entries gives you the values keyed by those ids. Read that section before you build anything, because a workflow that skips the map runs cleanly and delivers rows nobody can read. This guide covers the credential, the connect steps, the response shapes worth knowing, the two request limits, the full node reference and troubleshooting.
Before you start
- A Wufoo account. The API is available on every plan, including the Free one, but the daily request allowance differs by plan and that is the boundary that matters here. As read on 1 September 2026, Wufoo's pricing page lists 100 API requests a day on the Free plan and 10,000, 25,000, 50,000 and 100,000 on Starter, Professional, Advanced and Ultimate. A Free account is enough to connect and run a light scheduled read, and not enough for anything that pages through entries or polls frequently.
- At least one form built in the Wufoo editor. This integration reads and feeds forms rather than creating them, so there is nothing to automate until a form exists.
- Your Wufoo account subdomain, meaning the part before wufoo.com in your Wufoo address. It goes on the credential rather than on a node, because a Wufoo API key belongs to exactly one account.
- A Wufoo API key, found inside the Wufoo app rather than in a developer portal. It is per user rather than per form, so it reaches every form that user can see and no others.
- A decision about which Wufoo user's key to use. Every node acts as that user, so a key belonging to someone who can see all the forms you intend to automate avoids a class of empty result that looks like a broken connection. On a Free or Starter account there is a single user, so the choice makes itself.
- A Mattering workspace with access to the Automations app.
Find your Wufoo subdomain and API key
Wufoo authenticates with HTTP Basic and puts the API key in the username position, with the password ignored. The credential in Mattering therefore asks for two things rather than a username and password: the account subdomain and the API key. Both live in the Wufoo app, and neither requires a developer account or an approval step.
Connect Wufoo to Mattering
Verify it works
Open any automation canvas and check the palette: a Wufoo section should list the read and action nodes. Drop Wufoo: List Forms on the canvas and run a test step. It is the integration's natural probe, because it takes no required parameters and returns the one value everything else needs, which is each form's hash at data.Forms[].Hash. Read the names that come back and confirm they are the forms you expected, since this list is exactly what the acting key can see and nothing more.
Now run Wufoo: List Form Fields with a hash from the previous step. This is the step worth doing before you trust anything else, because it is the map that makes entries readable: every question comes back with its opaque id, its human title and its type. Look for the composite questions while you are here. A Name field appears once with subfields for first and last carrying their own ids, and a checkbox group appears once with one id per box. Those subfield ids are what entries actually contain, so this is the moment to see it rather than when a spreadsheet is full of blanks.
Finish with Wufoo: List Form Entries against the same form. Compare a row to the map you just read: the keys are ids, the titles are not in the payload, and joining the two is the work. If the form has no entries yet, Wufoo: Count Form Entries confirms the connection just as well and costs one request. Everything in this verify path is read only, so it never reaches the submit node or the webhook delete, and it is safe to re-run whenever you want to check the connection. Keep the count of test runs in mind on a Free account, where the daily allowance is small.
Node reference
17 nodes, generated from the connector itself so this reference always matches what ships.
Read and query nodes 14
Wufoo: Count Entry Comments
wufoo_count_comments
Count the comments on a form's entries. Note the shape difference from the entry counter, which is easy to get wrong: this one answers data.Count as a NUMBER, while Wufoo: Count Form Entries answers data.EntryCount as a STRING.
Wufoo: Count Form Entries
wufoo_count_entries
Count a form's entries without downloading them. Cheap enough to poll and useful as the gate on a workflow that should only run when something new arrived. The count comes back as data.EntryCount and Wufoo sends it as a STRING, so compare it as text or coerce it before doing arithmetic. It counts the whole form: this endpoint takes no filters.
Wufoo: Count Report Entries
wufoo_count_report_entries
Count the entries a saved report covers, without downloading them - useful because the report entries node has no pagination and pulls everything. Answers data.EntryCount as a STRING, like the form counter.
Wufoo: Get Form
wufoo_get_form
Get one form's settings: its name and description, whether it is public, its start and end dates, its entry limit and its redirect message. Note the shape: Wufoo returns a ONE-ELEMENT Forms array rather than a bare object, so the path to read is data.Forms[0].Name. This node does not return the form's questions - use Wufoo: List Form Fields for those.
Wufoo: Get Report
wufoo_get_report
Get one saved report's details: its name, description, public flag, dates and the links to its own fields, entries and widgets. Same shape trap as the single form: Wufoo returns a ONE-ELEMENT Reports array, so read data.Reports[0].Name.
Wufoo: List Account Users
wufoo_list_users
List the users on the Wufoo account, with each one's name, email, company, timezone, avatar and permission flags (IsAccountOwner, AdminAccess, CreateForms, CreateReports, CreateThemes). Note that Wufoo's documented payload also includes a live ApiKey for EVERY user, which is a working credential for the whole account. Mattering REDACTS that field before the node returns, so the value never reaches a log, a message, a spreadsheet or an AI step. Everything else in the row is returned unchanged.
Wufoo: List Entry Comments
wufoo_list_comments
Read the comments your team has left on this form's entries in the Wufoo app: the comment text, who wrote it, when, and which entry it belongs to. Narrow to a single entry with the entry id. The API is read-only on comments - there is no endpoint to write one - so this is for pulling internal notes into a summary or a ticket rather than for round-tripping them.
Wufoo: List Form Entries
wufoo_list_entries
Read a form's submitted entries. Each row carries EntryId, DateCreated, CreatedBy, DateUpdated, UpdatedBy and one key per answered field - keyed by the field's OPAQUE ID, never by its question text. Run Wufoo: List Form Fields against the same form to turn Field105 into a title; nothing in this response does that for you. Filter with expressions like "EntryId Is_greater_than 100" or "DateCreated Is_after 2026-03-01 00:00:00", sort by any field, and page with pageStart and pageSize (up to 100 rows). There is no cursor and no more-pages flag: a page shorter than pageSize is the end.
Wufoo: List Form Fields
wufoo_list_form_fields
Get a form's field map: for every question its opaque id (Field105 and so on), its human title, its type, whether it is required, its default value and the page it sits on. This is the node the rest of the connector depends on. Wufoo entries are keyed by field id and carry no question text at all, so without this map an entry is a row of unlabelled values and a submission is guesswork. Composite questions expand: a Name field returns SubFields for first and last with their own ids, an Address returns six, and a checkbox group returns one id per box - and it is those SUB-field ids that entries use. Choice fields return a Choices array whose labels are the exact strings entries contain.
Wufoo: List Forms
wufoo_list_forms
List the forms this API key can see, with each form's name, description, public flag, start and end dates, entry limit and - the value everything else needs - its hash. Takes no required parameters, so it doubles as the credential health check: 200 means the key and subdomain match, 401 means they do not. This is the first node in the form to fields to entries chain that makes Wufoo data readable.
Wufoo: List Report Entries
wufoo_list_report_entries
Read the entries a saved report covers, with the report's own filtering already applied - which is the point of using this instead of the form's entries node when someone has already built the view you want in Wufoo. Rows are keyed by opaque field ids exactly as form entries are, so pair it with Wufoo: List Report Fields. Note what it does NOT take: Wufoo documents no pageStart, pageSize, sort or filter parameters here, so this returns the report's whole dataset in one response and a large report is a large payload.
Wufoo: List Report Fields
wufoo_list_report_fields
Get the field map behind a report - the fields of the form the report is built on, with the same ids, titles, types and SubFields that Wufoo: List Form Fields returns. Use it for the same reason: report entries are keyed by opaque field ids too, so this is what makes them readable when you are working from a report rather than from the form.
Wufoo: List Report Widgets
wufoo_list_report_widgets
List the widgets that make up a report: each widget's name, display size, type (pie, fieldChart, bigNumber and so on) and hash. This returns the report's LAYOUT, not the numbers in it - Wufoo publishes no endpoint that returns a widget's computed value, so use this to see how a report is put together and Wufoo: List Report Entries to get data you can chart yourself.
Wufoo: List Reports
wufoo_list_reports
List the saved reports this API key can see, with each report's name, description, public flag and hash. A Wufoo report is a saved view over one form's entries, built in the Wufoo app; the API can read reports but cannot create or change them. This node takes no parameters and is not paginated.
Action nodes 3
Wufoo: Add Form Webhook
wufoo_create_webhook
Point a form at a webhook URL so Wufoo posts each new entry to it. MANAGEMENT ONLY: this configures Wufoo to call an endpoint YOU already run, and Mattering is not a delivery target for Wufoo webhooks - nothing in this platform receives or verifies one. SAVE THE RETURNED HASH from data.WebHookPutResult.Hash: Wufoo publishes no endpoint that lists a form's webhooks, so that value is the only way to delete this subscription later. Turn on metadata if your receiver needs the field structure alongside the values, which it will, for the same opaque-field-id reason the rest of this connector has to work around. Reverse by deleting the webhook.
Wufoo: Delete Form Webhook
wufoo_delete_webhook
DESTRUCTIVE. Remove a webhook subscription from a form, so Wufoo stops posting new entries to that URL. What is lost is the delivery itself and the ability to find it again: Wufoo ships NO endpoint that lists a form's webhooks, so once the subscription is gone the API cannot tell you what URL, handshake key or metadata setting it had. Re-creating it means knowing those values from your own records, and the new subscription gets a new hash. Entries submitted while no webhook is attached are stored in Wufoo but are never delivered, and there is no replay.
Wufoo: Submit Form Entry
wufoo_submit_entry
Submit an entry to a form exactly as a respondent would, so the form's own notifications, rules and integrations fire. The answers are keyed by Wufoo FIELD IDS, so read the map with Wufoo: List Form Fields first; sending question titles submits nothing. TWO THINGS WILL BITE. First, a rejected entry is not an HTTP error: when the form's validation fails Wufoo answers with data.Success 0 and a data.FieldErrors array, and the documented status for that can be 200, so branch on data.Success rather than on the node succeeding. Second, there is no delete-entry endpoint in this API, so a test submission is removed by a person in the Wufoo app. Wufoo also caps submissions at 50 per user per rolling five minutes and answers HTTP 429 past that.
Using the integration
The chain that makes Wufoo data readable
Wufoo entry payloads are keyed by opaque field ids and never by the question a respondent answered, so a row arrives as EntryId, DateCreated and a set of ids such as Field1, Field2 and Field105 with their values. Nothing in that payload says which question Field105 was. The titles live in a separate call, which is why the readable unit of work in this integration is a chain rather than a node: Wufoo: List Forms gives you the hash, Wufoo: List Form Fields gives you the id to title map for that form, and Wufoo: List Form Entries gives you the values. Join the last two in a following step and the row becomes readable. Three wrinkles in the map decide whether that join is correct. A Name field is one entry in the list with subfields for first and last that carry their own ids, an Address expands into six, and a checkbox group returns one id per box, and in every case it is the SUBFIELD ids that entries contain rather than the parent. Choice questions carry a list of labels, and an entry contains the label text rather than an index. Read the map on every run rather than hardcoding ids: a question added in the Wufoo editor changes what a row contains, and a workflow that reads the map absorbs that instead of quietly dropping the new answer. The one place the config panel solves this for you is the sort field on Wufoo: List Form Entries, which lists the chosen form's fields by their human title and submits the id Wufoo wants.
Response shapes, and the two that catch everyone
Wufoo sends no envelope of its own, so a node's data is the raw response body. Most endpoints return a keyed array, so a form list reads data.Forms and a field map reads data.Fields. Two shapes break that pattern and both are easy to get wrong. First, a single object is still wrapped in an array: Wufoo: Get Form returns a one element Forms array rather than a bare object, so the path is data.Forms[0].Name, and Wufoo: Get Report behaves identically. Second, the two counters disagree with each other despite looking like a matched pair: Wufoo: Count Form Entries answers data.EntryCount as a STRING, while Wufoo: Count Entry Comments answers data.Count as a NUMBER. More generally, numbers arrive as strings almost everywhere in this API, including required flags and public flags, so a downstream comparison should compare text or coerce explicitly rather than assuming a numeric type.
Filtering, sorting and paging entries
Wufoo: List Form Entries is the only node with a real filter language, and it is what makes an incremental pull possible. A filter is written as a field id, an operator and a value, for example EntryId Is_greater_than 100 or DateCreated Is_after 2026-03-01 00:00:00. Several filters combine with AND or OR. The operators are Contains, Does_not_contain, Begins_with, Ends_with, Is_less_than, Is_greater_than, Is_on, Is_before, Is_after, Is_not_equal_to, Is_equal_to and Is_not_NULL, and the left side is a field id from the form's map or one of the system columns EntryId and DateCreated. One point of confusion comes straight from Wufoo's own documentation, which writes the separator as a plus sign because that is how a space is encoded in a URL. The plus is not literal. Mattering accepts either spelling and normalises it, so write spaces if you find them clearer. Paging works by position rather than by cursor: set the start index and the page size, up to 100 rows, and add the size to the start for the next page. There is no cursor and no more-pages flag anywhere in this API, so a page shorter than the size you asked for is the end of the data. Timestamps carry no timezone marker and are rendered in the account's own timezone, which is a per-user setting, so pin the boundary of a date filter against a live account rather than assuming UTC.
Submitting entries, and the failure that does not look like one
Wufoo: Submit Form Entry posts an entry exactly as a respondent would, so the form's own notifications, rules and integrations fire from it. Key the payload by field ids read from the form's map, using the subfield ids for composite questions, one id per ticked checkbox, and the choice label rather than an index. Dates go as YYYYMMDD, and file upload fields cannot be filled over this API at all, so an entry submitted here leaves them empty. Now the part that matters most in this whole guide. A saved entry answers HTTP 201, but an entry REJECTED by the form's own validation, meaning a required field left blank, text in a number field, a closed form or a form past its entry limit, comes back with a Success value of 0 and a FieldErrors array naming the field ids that failed, and Wufoo documents that response under HTTP 200 as well as 400. Because a step succeeds on any 2xx, a rejected submission arrives looking like a success. Branch on data.Success rather than on the node succeeding, and read data.FieldErrors to find the question at fault. Mattering deliberately does not rewrite the result from a body field, because inventing a failure out of a payload would be this integration deciding what success means for every workflow that uses it. One more thing to design around: this API publishes no delete-entry and no update-entry endpoint, so a test submission is removed by a person in the Wufoo app rather than by a following node. Test against a throwaway form.
Webhooks are management only
Wufoo: Add Form Webhook points a form at a URL so Wufoo posts each new entry to it, and Wufoo: Delete Form Webhook removes that subscription. Read what these do carefully, because the naming invites a wrong assumption: they configure an endpoint YOU already run, and Mattering is not a delivery target for Wufoo webhooks. Nothing on this platform receives, verifies or triggers on a Wufoo delivery, so this connector has no trigger nodes and Wufoo workflows run on a schedule. Turn the metadata option on when you create one, or your receiver gets Field105 with no idea what question that was, which is the same opaque id problem now on somebody else's server. The handshake key is passed straight through for your receiver to check; Mattering neither generates nor verifies it. Save the hash the create node returns at data.WebHookPutResult.Hash, because Wufoo publishes no endpoint that lists a form's webhooks. That is also why the delete node is flagged destructive while most deletes are not: once a subscription is gone, the API cannot tell you what URL, handshake key or metadata setting it had, re-creating it means knowing those values from your own records, the replacement gets a new hash, and entries submitted while no webhook is attached are stored in Wufoo and never delivered, with no replay.
Saved reports, and what widgets actually return
A Wufoo report is a saved view over one form's entries, built in the Wufoo app. Wufoo: List Reports finds them, Wufoo: Get Report reads one, and Wufoo: List Report Entries returns the rows the view covers with its filtering already applied, which beats rebuilding somebody else's filter inside a workflow. Report rows are keyed by opaque field ids exactly as form entries are, so pair it with Wufoo: List Report Fields for the same reason. Two limits shape how you use them. The report entries endpoint takes no paging, sorting or filter parameters at all and returns the report's whole dataset in one response, so run Wufoo: Count Report Entries first when a report might be large, and expect a single big payload rather than a walk. And Wufoo: List Report Widgets returns a report's LAYOUT, meaning each widget's name, display size, type and hash, never the number displayed in it, because Wufoo publishes no endpoint that returns a widget's computed value. Use it to see how a report is put together, and use the report's entries to compute the numbers yourself. The API cannot create or change a report either, so reports come from the Wufoo app and this integration reads them.
The users endpoint returns credentials, and Mattering strips them
Wufoo: List Account Users returns the users on the account with their names, emails, company, timezone, avatars and permission flags, which is genuinely useful for routing and for auditing who can create forms. It also returns something you almost certainly do not want moving through a workflow: Wufoo's documented payload includes a live API key for EVERY user on the account, and each of those is a working credential for the whole account. Node output routinely lands in a run log, a spreadsheet, a chat message or an AI step's context, and an agent driving this over MCP forwards whatever it is handed, so a warning in a description would not have been enough protection. Mattering strips that field before the node returns and everything else in the row comes back unchanged. Treat the rest as staff personal data and select the fields a workflow needs rather than forwarding whole user objects around. Worth noting alongside it: no other endpoint in this API takes a user identifier, so this node is a directory read rather than the start of a chain, and there is no user create, update or delete.
Two request limits, and designing inside them
Wufoo restricts API usage per key per day, and the allowance depends on the plan rather than being one number for everybody. Wufoo's API documentation says so and points at its pricing page for the figures; as read on 1 September 2026 that page lists 100 API requests a day on the Free plan and 10,000, 25,000, 50,000 and 100,000 on Starter, Professional, Advanced and Ultimate. Separately, and documented as a fixed number in the API docs rather than on a pricing page, entry submissions are capped at 50 per Wufoo user in a rolling five minute window, answered with HTTP 429 and a Slow Down body. The two are different mechanisms with different fixes, so do not merge them: a 429 on a read means the day's allowance, while a 429 on a submit usually means the five minute window. Neither is retried inside the integration on purpose, because backoff belongs in the workflow where you can see it and adjust it. Three design habits keep you inside the budget. Gate scheduled work on Wufoo: Count Form Entries so a run that has nothing to do costs one request rather than a page walk. Filter incrementally rather than re-reading a form's whole history every night. And on a Free account, remember that a single 100 request allowance covers every workflow, every test run and every picker refresh on that key.
On the automation canvas
Wufoo nodes chain with every other node in Mattering, and the pickers do some of the wiring for you: the form field on nine nodes and the report field on five are populated from the listers, so you choose a form by name and the node receives its hash. That matters more than convenience, because Wufoo accepts either a hash or a form's URL title and a title changes the moment somebody renames the form in the editor, at which point a workflow that hardcoded it starts returning 404s. The pickers always supply the hash. The sort field on Wufoo: List Form Entries is fed by the field lister and gated on the form you chose, so it lists that form's questions by title. A few fields stay free text by design rather than being unfinished: the webhook hash on Wufoo: Delete Form Webhook has no lister to read because Wufoo publishes none, and the entry id filter on Wufoo: List Entry Comments is normally templated in from an upstream node, since a Wufoo entry has no name and a picker over it would offer an arbitrary window of ids while looking authoritative. Because there are no trigger nodes here, a Wufoo workflow starts on a schedule or on another app's event and reads, rather than waiting for Wufoo to push.
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. Neither Wufoo nor SurveyMonkey publishes an MCP server, and Wufoo's developer documentation does not mention MCP anywhere, so there is no vendor alternative to weigh here. The split worth making is generous on the fourteen reads and careful with the writes: an agent reading a form's field map and summarising a week of entries is low risk and genuinely useful, while Wufoo: Submit Form Entry fires the form's notifications and integrations at real people and cannot be undone through this API, and Wufoo: Delete Form Webhook silently stops deliveries with no way to look up what it removed. Put those behind a condition or an approval step. The advantage of running Wufoo here rather than in a local assistant config is that the same nodes are canvas steps, so the workflow an agent helps you design then runs on a schedule with nobody present, chains with every other connector, and holds the credential once in a shared workspace rather than in each person's machine.
Troubleshooting
Test Connection fails with a 401
Test Connection fails with a 404
The connection passes but a form picker is empty, or a form is missing from it
Entries come back as Field105 and similar instead of the questions that were asked
A submit step succeeded but no entry appeared in Wufoo
A submit step fails with a 429 and a Slow Down body
Reads start failing with a 429 partway through the day
A path expression reading a single form or report returns nothing
A filter on the entries node matches nothing at all
A webhook needs removing and the hash is nowhere to be found
A node for creating a form, editing a question or deleting an entry cannot be found
Related
The Wufoo MCP
What connecting Wufoo 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.
Wufoo 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.