Menu

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.

Sign in to Wufoo and note the subdomain in your address bar. In https://example.wufoo.com the subdomain is example. You can paste the whole address later if you prefer; Mattering reduces it to the account name.
Open the Form Manager and pick any form.
Open that form's More menu and choose API Information. The code shown on that page is your API key.
The key is per USER, not per form. The same code appears on every form's API Information page for that user, and it reaches every form that user can see. A second Wufoo user on the same account has a different key with different visibility, which is the usual reason a form somebody swears exists does not appear in a node's picker.
A Wufoo key only works against the account it was issued for, so the key and the subdomain have to belong together. A valid key paired with the wrong subdomain fails as a 401 that reads exactly like a bad key. If a connection test fails, check both fields rather than only the secret.
Keep the key somewhere safe on the way over. It is a working credential for every form its user can see, and this API has no scopes: a key that can read entries can also submit them.

Connect Wufoo to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Wufoo from the list.
Click Create new credential, then fill in Wufoo Subdomain with the account name and API Key with the code from the API Information page. The labels are deliberately not Username and Password: the API key goes in the API Key field, and your Wufoo login is never used here.
The API key is stored encrypted and never appears in workflow logs. The subdomain lives on the credential alongside it rather than on each node, because an API key belongs to exactly one Wufoo account and a per-node account field could only ever let a workflow contradict its own key.
Click Test Connection. Mattering calls your account's forms endpoint, which needs no parameters and is the cheapest authenticated read in the API. A pass proves the subdomain resolves to a real Wufoo account, that the key is valid for that account, that the key is being sent in the right position, and that the day's request allowance is not spent.
A pass does not prove the key can see any particular form. Wufoo keys are per user, so an account with forms belonging to somebody else returns an empty list here and still passes. That is a correct result, and it is also an empty picker.
All 17 Wufoo nodes appear in your canvas palette.

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
The key and the subdomain do not belong together, or the key is wrong. A Wufoo API key only works against the account it was issued for, so a perfectly valid key paired with another account's subdomain produces exactly this, which is why it is worth re-checking the subdomain rather than assuming the secret is at fault. Confirm the subdomain is the account name in your Wufoo address, meaning the example in https://example.wufoo.com, and not a form name. Then re-copy the key from any form's API Information page under its More menu, and make sure it went into the API Key field: Wufoo puts the key in the HTTP Basic username position, so a key pasted somewhere it was mistaken for a password fails here.
Test Connection fails with a 404
There is no Wufoo API at the host that was tried, which almost always means the subdomain is not an account name. The most common version of this is pasting a form's URL title or a report slug into the subdomain field. Open Wufoo and read the address bar: the value you want is the label immediately before wufoo.com. Pasting a full address is fine, since Mattering reduces https://example.wufoo.com/forms/abc to example.
The connection passes but a form picker is empty, or a form is missing from it
This is a correct result rather than a fault, and it comes from Wufoo's per-user key model. An API key is per user, not per form or per account, and it reaches only the forms that user can see. So a key belonging to a teammate who cannot see the form you want returns an empty or partial list, and the connection test still passes because the request itself succeeded. Run Wufoo: List Forms on its own to see exactly what the acting key can see. The fix is to use the key of a Wufoo user with visibility of the forms you intend to automate, taken from that user's own API Information page.
Entries come back as Field105 and similar instead of the questions that were asked
That is how Wufoo represents an entry, not a fault in the read. Entry payloads are keyed by opaque field ids and carry no question text at all. Run Wufoo: List Form Fields against the same form to get the id to title map and join the two downstream. Watch the composites while you do: a Name field, an Address and a checkbox group each appear once in the map with subfields carrying their own ids, and it is those subfield ids that entries contain, so joining only on parent ids leaves the values that matter unlabelled.
A submit step succeeded but no entry appeared in Wufoo
The form almost certainly rejected the entry, and Wufoo did not use an HTTP error to say so. A validation failure, 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, documented under HTTP 200 as well as 400. Since a step succeeds on any 2xx, that arrives as a successful step. Read data.Success in the node's output and branch on it, then read data.FieldErrors to see which field ids failed. The other cause to check is the payload keys: sending question titles instead of field ids submits nothing useful, and composite questions need their subfield ids rather than the parent.
A submit step fails with a 429 and a Slow Down body
That is the submission limit rather than the daily allowance, and the two have different fixes. Wufoo caps entry submissions at 50 per Wufoo user in a rolling five minute window and answers HTTP 429 with a Slow Down body past it. It applies to Wufoo: Submit Form Entry only. Space the submissions out, batch them across runs, or spread them across more than one Wufoo user's key if the volume is genuinely that high. Nothing retries automatically inside the integration, so add the wait to the workflow where you can see it.
Reads start failing with a 429 partway through the day
This is the other limit: Wufoo restricts API usage per key per day and the allowance depends on the plan. As read on 1 September 2026, Wufoo's pricing page lists 100 API requests a day on the Free plan and larger allowances on the paid tiers. The allowance is per key, so every workflow, every test run and every picker refresh on that credential draws from the same pool. Gate scheduled work on Wufoo: Count Form Entries so a run with nothing to do costs one request instead of a page walk, filter entries incrementally instead of re-reading a form's whole history, and reserve the report entries node for when you need it, since it returns a report's entire dataset in one call.
A path expression reading a single form or report returns nothing
The single-object endpoints do not return a bare object. Wufoo: Get Form returns a one element Forms array, so the path is data.Forms[0].Name rather than data.Form.Name, and Wufoo: Get Report behaves the same way with data.Reports[0]. This is the shape mistake most likely to be made against this API. While you are checking paths, note that the two counters differ from each other: entries answer data.EntryCount as a string and comments answer data.Count as a number, and numbers arrive as strings almost everywhere else too, so compare as text or coerce explicitly.
A filter on the entries node matches nothing at all
Check the left side and the value separately. The left side has to be a field id from Wufoo: List Form Fields or one of the system columns EntryId and DateCreated, so a question title there matches nothing by definition. For choice questions the value is the choice LABEL exactly as it appears in the map, not an index. If you copied the syntax out of Wufoo's documentation, note that the plus signs in it are how a space is encoded in a URL rather than literal characters; Mattering accepts either spelling and normalises it, so this is a reason to check the field id rather than the separator. For a date comparison, remember that Wufoo timestamps carry no timezone marker and are rendered in the account's own timezone, so a boundary that looks right in UTC can sit an hour or more off.
A webhook needs removing and the hash is nowhere to be found
There is no way to look it up, and it is worth knowing why rather than searching for a node that does it. Wufoo publishes PUT and DELETE on webhooks and no GET of any kind, so no endpoint anywhere lists a form's webhooks. The hash exists in exactly one place, the response of Wufoo: Add Form Webhook at data.WebHookPutResult.Hash, which is why that node's description says to keep it and why the delete node's hash field is free text rather than a picker. If the value was not recorded, the subscription can be removed from the form's settings inside the Wufoo app instead. Store the hash somewhere durable when you create a webhook from a workflow, for example in a Mattering database row next to the form hash.
A node for creating a form, editing a question or deleting an entry cannot be found
Those endpoints do not exist in Wufoo's v3 API, so no node can exist for them. There is no form create, update or delete, no question or field editing, no entry update and no entry delete, no comment write, no report create or update, no widget value, no webhook listing or delivery replay, and no user management. Forms are built in the Wufoo editor and this integration reads them and feeds them. The practical consequence to plan for is that a test submission is cleaned up by a person in the Wufoo app rather than by a following node, so run write tests against a throwaway form. One endpoint is omitted on purpose rather than absent from the API: Wufoo's login endpoint exchanges a user's email and password for their API key, and modelling it would put an account password into a workflow config field.

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.

Start Free Explore our Products