Menu
Mattering Automations connector

A Wufoo MCP built around the thing that breaks Wufoo automations

17 nodes on Wufoo API v3: forms and their field maps, entries and entry counts, comments, saved reports, report entries and widgets, and account users, plus three writes for submitting an entry and managing a form's webhook. Wufoo entries come back keyed by opaque ids like Field105 and carry no question text at all, so the connector is shaped around the read that makes them readable rather than pretending the problem is not there.

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

What the Wufoo MCP connector does

The Wufoo connector for Mattering Automations is 17 nodes on Wufoo's v3 API, fourteen that read and three that act. Wufoo, now part of SurveyMonkey, is a form builder, and its API is a read surface over what the form editor produced: the forms an API key can see, each form's field structure, the entries people submitted, the comments a team left on those entries, the saved reports built over a form, the widgets that make up a report, and the users on the account. Three endpoints write: submit an entry, add a webhook to a form, delete a webhook from a form. That is the whole published surface, and this connector covers all of it apart from one endpoint deliberately left out.

Every capability is a node on the Automations canvas, and every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. The same nodes are also steps in a visual workflow, so the thing an agent helps you work out interactively can then run on a schedule with nobody present, chained with every other connector in the same workflow.

Here is the fact that decides whether a Wufoo automation is worth building. Wufoo entry payloads are keyed by opaque field ids and never by the question a respondent answered. A row arrives as EntryId, DateCreated and then Field1, Field2, Field105 and so on, with nothing anywhere in it saying which question Field105 was. The human titles live in a separate call. So the readable unit of work is a chain rather than a node: Wufoo: List Forms gives you the form hash, Wufoo: List Form Fields gives you the id to title map for that form, and Wufoo: List Form Entries returns the values keyed by those ids. The fields call is a hard dependency, not an optional extra, and a workflow that skips it produces rows of unlabelled values that a person then decodes by hand.

The same map is what a write needs. Wufoo: Submit Form Entry posts Field105 as a key, so composing a submission without reading the fields first is guesswork. Composite questions make it sharper: a Name field expands into subfields for first and last with their own ids, an Address expands into six, a checkbox group returns one id per box, and it is those subfield ids that entries actually use. Choice fields carry the label text, not an index. The one place the config panel can solve this for you is the sort field on the entries node, which lists a form's fields by their human title and submits the id Wufoo wants.

One node returns something that should never leave the run. Wufoo's documented users payload includes a live API key for every user on the account, which is a working credential for the whole account, and node output routinely lands in a run log, a spreadsheet, a chat message or an AI step's context. Mattering strips that value before Wufoo: List Account Users returns, so the key never reaches any of those places. Names, emails, company, timezone and the permission flags come back unchanged, which is what the node is actually for.

Be honest with yourself about what this API cannot do before you plan around it. There is no form create, update or delete and no way to edit a question. There is no entry update and no entry delete, so a test submission is removed by a person in the Wufoo app rather than by a follow up node. Comments are read only. Reports cannot be created or changed, and the widgets node returns a report's layout rather than the numbers in it. There is no endpoint that lists a form's webhooks, no delivery log and no replay. There are no analytics, folder, theme or user management endpoints, and file upload fields cannot be filled over the API.

Two request limits apply and they are separate mechanisms. Wufoo caps API requests per key per day and the allowance depends on the plan. As read on 1 September 2026, Wufoo's pricing page lists 100 requests a day on the Free plan and 10,000, 25,000, 50,000 and 100,000 on Starter, Professional, Advanced and Ultimate. Separately, Wufoo's API documentation caps entry submissions at 50 per Wufoo user in a rolling five minute window and answers HTTP 429 with a Slow Down body past that. Neither is retried inside the connector, because backoff belongs in the workflow where you can see it.

One connection, three surfaces

  • Visual automations. Drag Wufoo nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Wufoo node, ready to drop on the canvas

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

Read and query nodes 14

Wufoo: Count Entry 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Connecting Wufoo takes one credential

The API key is inside the Wufoo app rather than in a developer portal. Sign in, open the Form Manager, pick any form, and choose API Information from that form's More menu. The code on that page is your key. Two things about it are easy to get wrong. It is per user rather than per form, so the same key appears on every form's API Information page for that user and reaches every form that user can see, while a second Wufoo user on the same account has a different key with different visibility. And the key belongs to exactly one account, which is why the credential also asks for the subdomain, meaning the part before wufoo.com in your Wufoo address. A key paired with the wrong subdomain fails as a 401 that looks like a bad key.

1

Decide which Wufoo user should hold the connection. A Wufoo API key is per user and only reaches the forms that user can see, so a key belonging to someone who can see every form you intend to automate beats an individual's personal one. On a Free or Starter account there is one user, so this decides itself.

2

In Wufoo, open the Form Manager, pick any form, and choose API Information from its More menu. Copy the key shown there.

3

Note your subdomain. It is the account name in your Wufoo address, so in https://example.wufoo.com the subdomain is example. Pasting the whole address works too: the connector reduces it to the account name.

4

In Mattering Automations, open Connectors, click Add Connector and choose Wufoo, then create a new credential and fill in the subdomain and the API key.

5

Click Test Connection. Mattering calls your account's forms endpoint, which is the cheapest authenticated read in the API and the one every picker in the connector reads from, so a pass here is a pass for the config panel too. A 401 means the key and the subdomain disagree, a 404 means the subdomain is not a Wufoo account, and a 429 means the day's request allowance is spent.

6

All 17 Wufoo nodes appear in the canvas palette. Run Wufoo: List Forms, then Wufoo: List Form Fields on a form hash from it, before you touch anything that reads or writes entries. An empty form list is a pass on the connection and still an empty picker, because the key only sees its own user's forms.

Common uses for the Wufoo MCP

Turn a form's entries into rows a person can actually read

This is the workflow everything else is built on. Wufoo: List Forms supplies the hash, Wufoo: List Form Fields returns the id to title map, and Wufoo: List Form Entries returns the values. Joining the two in a following step is what turns Field105 into the question that was asked, and doing it in that order is what stops a spreadsheet or a database from filling with anonymous columns. Keep the map in the workflow rather than hardcoding ids: adding a question in the Wufoo editor changes what a row contains, and a workflow that reads the map every run absorbs that instead of breaking on it.

A nightly incremental pull instead of downloading everything

Wufoo: List Form Entries takes filter expressions, so a scheduled run can ask for only what arrived since the last one with an expression like DateCreated Is_after 2026-03-01 00:00:00, or hold an EntryId high water mark and ask for anything greater. Page with the start and size parameters, up to 100 rows a request. There is no cursor and no more-pages flag anywhere in this API, so a page shorter than the size you asked for is how you know you reached the end. Worth knowing before you tune the schedule: Wufoo timestamps carry no timezone marker and are rendered in the account's own timezone, so pin the boundary against a real account rather than assuming UTC.

An entry-count gate so work only runs when something arrived

Wufoo: Count Form Entries returns a form's total without downloading a single row, which makes it cheap enough to poll and the natural first step on a scheduled workflow that should do nothing most of the time. Compare it against the last stored value and only continue when it moved. Two details save an afternoon: the count comes back as a string rather than a number, so coerce it before doing arithmetic, and the endpoint takes no filters, so it counts the whole form. That matters more here than on most connectors, because a Free account's daily request allowance is small enough that a polling loop is the thing most likely to spend it.

Submit into Wufoo from another system or an agent

Wufoo: Submit Form Entry posts an entry exactly as a respondent would, so the form's own notifications, rules and integrations fire from it. Read the field map first and key the payload by field ids, using the subfield ids for composite questions, one id per ticked checkbox, and the choice label rather than an index. Then branch on the response body rather than on the node succeeding: when Wufoo rejects an entry for failing the form's own validation it answers with Success 0 and a FieldErrors array, documented under HTTP 200 as well as 400, so a rejected submission can arrive looking like a success. This is the single most likely way to build a Wufoo workflow that silently drops data.

A weekly digest from a report somebody already built

A Wufoo report is a saved view over one form's entries, built in the Wufoo app. Wufoo: List Report Entries returns exactly what that view covers, with its filtering already applied, which beats rebuilding the same filter in a workflow when a colleague has already defined it. Pair it with Wufoo: List Report Fields for the same reason form entries need a map, since report rows are keyed by opaque ids too. One caution shapes the design: this endpoint takes no paging, sorting or filtering parameters at all and returns the report's whole dataset in one response, so run Wufoo: Count Report Entries first if the report might be large. Wufoo: List Report Widgets tells you how a report is put together and returns its layout, never a computed number.

Point a form at your own webhook endpoint

Wufoo: Add Form Webhook tells Wufoo to post each new entry to a URL you already run, and Wufoo: Delete Form Webhook removes that subscription. These are management nodes only: Mattering is not a delivery target for Wufoo webhooks and nothing on this platform receives or verifies one, so this is for wiring Wufoo to a service of your own. Two things to plan for. Turn the metadata option on, or your receiver gets Field105 with no idea what question that was, which is the same opaque id problem now running on someone else's server. And save the hash the create node returns, because Wufoo publishes no endpoint that lists a form's webhooks, so that value is the only handle you will ever have on the subscription.

Example: A nightly sweep that turns new form entries into labelled records

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a nightly schedule fires. This connector has no trigger nodes, so Wufoo workflows run on a schedule and read, rather than listening for a push from Wufoo.

2

Wufoo: Count Form Entries returns the form's total. Compare it against the value stored on the last run and stop here when nothing moved, which keeps the daily request allowance for the runs that have work to do. Remember the count arrives as a string.

3

Wufoo: List Form Fields reads the form's field map, so this run knows which id belongs to which question. Doing it every run rather than once means a question added in the Wufoo editor since yesterday is handled instead of silently dropped.

4

Wufoo: List Form Entries pulls only what is new, with a filter such as EntryId Is_greater_than followed by the last id seen, sorted and paged up to 100 rows a request. A page shorter than the size requested is the end of the data.

5

A mapping step joins each row to the field map, so every value carries its question title instead of an id, and composite answers are reassembled from their subfield ids.

6

The labelled records land where the team works: a Mattering database, a CRM contact, a Productivity task for anything that needs a human, or an AI step that summarises the batch. Because the labels came from the map rather than from a hardcoded guess, the summary describes real questions.

7

The highest EntryId seen is stored for the next run. Nothing was written back to Wufoo, which is the right shape here: this API publishes no way to update or delete an entry, so a workflow that reads and labels is fully reversible and a workflow that writes is not.

Wufoo MCP questions, answered

What can this connector actually do in Wufoo?

17 nodes: 14 read and 3 act. The reads cover the forms an API key can see, a single form's settings, a form's field map, its entries and its entry count, the comments left on its entries and their count, the saved reports on the account, a single report, a report's field map, its entries and its entry count, the widgets that make up a report, and the users on the account. The writes are submitting an entry, adding a webhook to a form, and deleting one. What is not here, because Wufoo's v3 API does not publish it: creating, updating or deleting a form or editing its questions, updating or deleting an entry, writing a comment, creating or changing a report, reading a widget's computed value, listing a form's webhooks or replaying a delivery, any analytics, folder, theme or user management endpoint, and filling a file upload field. One endpoint is deliberately left out rather than missing, the login endpoint, because it exchanges a Wufoo user's email and password for their API key and would put an account password into a workflow config field.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and work with Wufoo through them. Matter, the assistant built into the platform, uses the same nodes natively. The same nodes are also steps on the automation canvas, so a workflow an agent helps you design can then run on a schedule with nobody present. The sensible split with Wufoo is generous on the reads and careful with the one write that matters: an agent reading entries and summarising them is low risk, while an agent submitting entries fires the form's notifications and integrations at real people and cannot be undone through this API.

Does Wufoo publish its own MCP server?

No. Neither Wufoo nor SurveyMonkey publishes an MCP server, and Wufoo's developer documentation does not mention MCP or the Model Context Protocol anywhere. So there is no vendor server to weigh this against, and this connector is the practical way to put Wufoo behind an MCP-capable assistant today. Beyond the protocol itself, running Wufoo here means the same 17 nodes are also canvas steps, so they run on a schedule with nobody present, chain with every other connector in one workflow, hold the credential once in a shared workspace store rather than in each person's local config, and carry a destructive flag on the one node that earns it.

Why do my entries come back as Field105 instead of the question I asked?

Because that is how Wufoo's API represents an entry, and it is the first thing to understand about automating Wufoo. Entry payloads are keyed by opaque field ids and carry no question text at all, so a row is EntryId, DateCreated and a set of Field ids with values. The human titles live in a separate call, the form's field map, which returns each field's id, title, type, whether it is required and its default. Run Wufoo: List Form Fields against the same form and join the two, and the row becomes readable. Three wrinkles in the map are worth reading before you write the join: a Name field expands into subfields for first and last with their own ids, an Address expands into six, and a checkbox group returns one id per box, and it is those subfield ids that entries carry rather than the parent. Choice fields carry a list of labels, and an entry contains the label text rather than an index.

What are Wufoo's rate limits, and does the free plan work?

Two separate limits, and merging them leads people to the wrong fix. Wufoo restricts API usage per key per day, and the allowance depends on the plan rather than being one number; 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, entry submissions are capped at 50 per Wufoo user in a rolling five minute window and answer HTTP 429 with a Slow Down body past that. Practically: a Free account is fine for a credential test and a light scheduled pull, and 100 requests a day is not enough for anything that pages through entries or polls often. Neither limit is retried inside the connector, so a 429 comes back as an ordinary failed step and backoff is something you add where you can see it.

Can an agent create a form, edit a question, or delete an entry?

No, and none of that is an omission in this connector. Wufoo's v3 API publishes no form create, update or delete, no way to add or edit a question, and no entry update or delete of any kind. Forms are built in the Wufoo editor and this connector reads them and feeds them. The direct consequence worth planning around is that a test submission cannot be cleaned up by a following node: somebody removes it in the Wufoo app. That is why the submit node is only reversible in the loosest sense, and why testing it against a throwaway form beats testing it against a live one. The nearest thing to a form-level write here is the webhook pair, which configures where Wufoo posts new entries rather than changing the form.

Is it safe to let an agent list the account's users?

Yes, because of a specific thing this connector does. Wufoo's documented users payload includes a live API key for every user on the account, and each of those is a working credential for the whole account. A node output routinely ends up in a run log, a spreadsheet, a chat message or an AI step's context, so a warning in a description would not have been enough. Mattering strips that field before Wufoo: List Account Users returns, so the value never reaches any of those places. Everything else in the row, meaning the name, email, company, timezone, avatar and the permission flags, is returned unchanged. Treat the rest as staff personal data and select the fields a workflow needs rather than forwarding whole objects around.

My submit node succeeded but no entry appeared. What happened?

Almost certainly the form rejected it, and Wufoo did not use an HTTP error to say so. A saved entry answers HTTP 201. An entry that fails 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 Success 0 and a FieldErrors array naming the field ids that failed, and Wufoo's documentation shows that response under HTTP 200 as well as 400. Since a step succeeds on a 2xx, a rejected submission arrives looking like a success. Branch on the Success value in the response body, not on the node succeeding, and read FieldErrors to see which question was the problem. The connector deliberately does not rewrite the result from a body field, because inventing a failure from a payload would be this connector deciding what success means for every workflow that uses it.

17 nodes waiting on the canvas

Put Wufoo to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Wufoo is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products