Menu

Mattering Automations Cognito Forms integration

Connect Cognito Forms to Mattering Automations: forms and form schemas, reading entries individually or through a grid view, creating and updating and deleting entries, bulk import with polled status, file upload and download, merged documents, and public link availability, authenticated with one bearer API key.

The Mattering Automations Cognito Forms integration puts both of the APIs Cognito Forms publishes on your automation canvas: list forms and read a form's schema, read one entry or many, create real submissions, update and delete entries, bulk import a spreadsheet and poll its status, upload files and download attachments and merged documents, and open or close a form's public link. 14 nodes in total, 8 reads and 6 actions.

Two things are worth settling before you start. The API is available to organizations on the Pro, Team and Enterprise plans; the free plan is called Individual and does not include it, so the New API Key option is simply not there on the free plan. And reading many entries does not work the way it does on most form APIs: there is no list-entries endpoint, and bulk reads run through a separate feed pointed at a grid view you build in the Cognito Forms app. That is covered step by step below, because it is the part most likely to stall a first build.

The credential is a single API key sent as a bearer token, created by an organization owner or administrator under Settings and Integrations. Setup takes a few minutes, and this guide walks through each step, including the scope choices that decide which nodes will work, and ends with the full node reference.

Before you start

  • A Cognito Forms organization on the Pro, Team or Enterprise plan. Cognito Forms documents the API as available on those plans, and the free Individual plan does not include it.
  • Owner or administrator access to that organization, because only those roles can create an API key.
  • At least one form. Cognito Forms: List Forms is how form ids reach the rest of the integration, and archived forms are never returned by it.
  • For anything that reads many entries at once, a GRID view built on the form in the Cognito Forms app. The view id is required and no endpoint supplies it, so this is a prerequisite rather than something the connector can resolve for you.
  • An idea of your request budget. The monthly allowance differs by plan, at 2,000 requests on Pro, 10,000 on Team and 100,000 on Enterprise, and it is shared with the vendor's own connectors for other automation tools and its JSON webhooks rather than reserved for this integration. Requests are counted in 100KB units, so large responses cost more than one, and a separate rate limit of 300 requests per 5 minutes applies on top.
  • A Mattering workspace with access to the Automations app.
  • Not needed and not stored here: a region, a subdomain or a base URL. Cognito Forms publishes one host for both of its APIs, which is why this integration takes nothing but the key.

Create a Cognito Forms API key

Cognito Forms authenticates every request, on both its REST API and its OData service, with one API key sent as a bearer token. The key is created per organization and carries two independent scopes that decide which operations it can perform. Choosing those scopes deliberately is the most consequential part of this step, because a scope you did not grant surfaces later as an authentication error rather than a permission one.

In Cognito Forms, open Settings and then Integrations.
Click New API Key and give it a name that says which system holds it.
If this option is not available, the organization is on the free Individual plan or you are not an owner or administrator. Cognito Forms documents the API as available on the Pro, Team and Enterprise plans.
Set the Form scope. Read allows listing forms and reading a form's schema. Read and write additionally allows setting public link availability, which is the only form-level write in the whole API.
Set the Entry scope. Read allows reading an entry, a file and a merged document. Read and write additionally allows creating and updating entries and uploading files. Read, write and delete additionally allows deleting an entry and the syncing mode of the bulk import.
Grant the delete level only if a workflow genuinely needs it. Deleting an entry removes a person's whole submission, the files they uploaded with it and any payment record attached to it, and Cognito Forms publishes no restore endpoint.
Choose an expiry date, or set the key never to expire, then create it.
Copy the key now. Cognito Forms states plainly that a key cannot be retrieved later, so a key you did not copy has to be replaced rather than recovered.

Connect Cognito Forms to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Cognito Forms from the list.
Click Create new credential, paste the API key, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs. Cognito Forms also documents a query-string alternative to the header for systems that cannot send one; this integration deliberately does not use it, because a credential in a URL lands in logs and referrers.
Click Test Connection. Mattering calls the forms endpoint, which takes no parameters at all. A pass proves the key is real, that it has not expired, that it carries the form read scope, that the organization is on a plan including the API, and that neither the rate limit nor the monthly allowance is currently exhausted.
A pass does not prove the entry nodes will work, because the Entry scope is granted separately. The reverse is the false negative to watch for: a key granted ONLY entry scopes fails this test while being perfectly usable for reading and writing entries.
Click Connect. All 14 Cognito Forms nodes appear in your canvas palette.

Verify it works

Open any automation canvas and drop Cognito Forms: List Forms onto it, then run a test step with no configuration. It returns every reachable form as a bare JSON array of id, name and internal name, so paths read data[].Id with no wrapper key. This is also the source for the form picker on every other node, so a successful run here is what makes those pickers populate. Archived forms are never included, which is expected rather than a fault.

Now check the schema read, because it is the lookup a writer needs. Drop Cognito Forms: Get Form Schema onto the canvas, pick a form from the Form picker, and run it. You get the form's fields with their data types, descriptions and valid values, addressed by the form's own field names. Set Input to true and run it again: that version shows only the properties the API will ACCEPT, which is what to build a create or an update against, since calculation fields are recomputed and upload fields cannot be written directly.

Finally, verify an entry read, which needs a different scope from the two above. If you already know an entry id, drop Cognito Forms: Get Entry on the canvas and run it. Values arrive as top-level properties named after the form's fields, with composite fields such as a name arriving as objects, and entry metadata under the reserved data.Entry property. To list entries instead, build a grid view in the Cognito Forms app first, copy its view id out of the OData feed URL on the form's entries page, and run Cognito Forms: List Entries in a View with the Select option set to the id column. Everything in this verify path is read-only, so it cannot reach the delete or import nodes.

Node reference

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

Read and query nodes 8

Cognito Forms: Get Document

cognito_forms_get_document

Generate and download one of a form's documents for a single entry: the merged PDF or Word file that a document template produces, such as a receipt or a signed agreement. The response is the same File shape as Cognito Forms: Get File, with a URL at data.File and the base64 bytes at data.Content, so the same 100KB-per-request billing warning applies. Cognito Forms publishes no endpoint that lists document templates, so the template id comes from the Cognito Forms app. Requires the Entry:Read scope.

Cognito Forms: Get Entry

cognito_forms_get_entry

Get one entry in full. The answer values are the top-level properties of the response and they are keyed by the form's own FIELD NAMES rather than by opaque ids, so a downstream step can read data.Email directly; a composite field such as Name is an object with sub-properties. Entry metadata sits under the reserved data.Entry property: the entry Number and Status and Role, the created and submitted and updated timestamps, the admin and public and internal and reviewer links, generated documents, and on a payment form the whole Order object with amounts and billing details. Treat the response as personal data: it is somebody's form submission. Requires the Entry:Read scope.

Cognito Forms: Get Entry from a View

cognito_forms_get_view_entry

Read one entry AS THAT VIEW SHOWS IT: only the view's columns and with values in the view's export formatting, so a signature field reads Captured or Not Captured rather than carrying data. Use this when a workflow pages a view and then needs one row back in the same shape it was listed in. For the full entry with its metadata and any payment Order attached use Cognito Forms: Get Entry instead, which returns considerably more. Requires the Entry:Read scope.

Cognito Forms: Get File

cognito_forms_get_file

Download a file somebody uploaded with an entry. The response carries the file's metadata plus BOTH a downloadable URL at data.File and the bytes themselves base64-encoded at data.Content. Prefer data.File when a downstream step can fetch a URL, because the base64 body is what makes this call expensive: Cognito Forms bills one API request per 100KB, so a 5 MB attachment costs about fifty requests out of a Pro plan's 2000 for the month. Treat the contents as personal data. Requires the Entry:Read scope.

Cognito Forms: Get Form Schema

cognito_forms_get_form_schema

Describe one form's fields: every field with its data type its description and its valid values. This is the lookup a writer needs, because Cognito Forms addresses entry values by FIELD NAME rather than by an opaque id, and this node is what tells you the exact property names to send. Composite fields such as Name and Address are objects with sub-properties rather than flat strings, and a choice field carries its allowed values, so read this before building Cognito Forms: Create Entry or Cognito Forms: Update Entry. Set Input to true to get the schema for what the API will ACCEPT rather than what it returns, which is the version that excludes calculations and other read-only properties. Requires the Form:Read scope.

Cognito Forms: Get Import Status

cognito_forms_get_import_status

Check how a bulk import went: its Status, how many entries succeeded and how many failed out of the total, an error message if the import itself failed, and a link to the annotated file that explains the failures row by row. An import runs in the background, so this is how a workflow learns the real outcome; poll it after Cognito Forms: Import Entries rather than treating that node's 200 as confirmation. Note that a completed import can still report UnsuccessfulEntries above zero, which is a partial success and needs branching on the number rather than on the node succeeding. Requires the Form:Read scope.

Cognito Forms: List Entries in a View

cognito_forms_list_view_entries

Read many entries at once. This is the ONLY way to list entries in Cognito Forms, and it runs through the separate OData service rather than the REST API, which has no list-entries endpoint at all. Entries are returned under data.value[] with the view's own COLUMN NAMES as properties and an integer Id per row. The VIEW is the filter: you define the columns and the conditions and the sort in the Cognito Forms app and this node returns exactly what that view shows, so there is no filter parameter to pass here. Only grid views are supported and the feed excludes repeating-section and table-field data, so a form whose payload lives in a repeating section has to be read one entry at a time with Cognito Forms: Get Entry. Requires both the Form:Read and Entry:Read scopes.

Cognito Forms: List Forms

cognito_forms_list_forms

List every form in the organization that this API key can reach, as an array of Id and Name and InternalName. Takes no parameters and is not paginated, so it doubles as the credential health check: 200 means the key works and holds the Form:Read scope. Archived forms are never included. This is where form ids come from, because almost every other Cognito Forms node needs one. Note the response is a bare JSON array, so paths read data[].Id with no wrapper key. Requires the Form:Read scope.

Action nodes 6

Cognito Forms: Create Entry

cognito_forms_create_entry

Create a real entry on a form, exactly as if it had been submitted. Values are addressed by FIELD NAME, so read the names and types from Cognito Forms: Get Form Schema first (with Input set to true, which shows only what the API will accept). The whole entry comes back including the fields you did not set, plus its metadata under data.Entry, so data.Id is available to undo this by deleting it. Two limits that are not obvious: calculation fields are recomputed and cannot be set, and file upload fields cannot be filled directly here, so a file goes through Cognito Forms: Upload File first and its returned id is what you send. Unlike some form APIs this is a live submission and will run the form's own workflow. Requires the Entry:Read/Write scope.

Cognito Forms: Delete Entry

cognito_forms_delete_entry

DESTRUCTIVE. Delete one entry: a person's whole form submission, every answer in it, any files they uploaded with it and the payment record attached to it on a payment form. Cognito Forms publishes no restore endpoint and no recovery window for an entry deleted through the API, so nothing in a workflow can undo this. Read the entry with Cognito Forms: Get Entry first if you need a copy. Returns HTTP 204 with no body. Requires the Entry:Read/Write/Delete scope, which is a scope a key does not have unless somebody deliberately granted it.

Cognito Forms: Import Entries

cognito_forms_import_entries

DESTRUCTIVE IN ONE MODE. Bulk create or update or delete entries from a .xlsx or .csv file. Mattering downloads the file from the URL you give it and forwards it to Cognito Forms. Import Mode decides everything: CreateNew only adds rows, UpdateExisting only changes matched rows, and SyncEntries makes the form MATCH THE FILE, which means entries absent from the file are DELETED with no restore endpoint. The call returns an import id immediately and the work happens in the background, so poll Cognito Forms: Get Import Status for the outcome rather than assuming the 200 means the rows landed. Requires the Form:Read and Entry:Read/Write/Delete scopes.

Cognito Forms: Set Public Link Availability

cognito_forms_set_form_availability

Open or close a form's public link on a schedule, and set the message a visitor sees while it is closed. This is the ONLY form-level write in the whole Cognito Forms API: everything else about a form is edited in the Cognito Forms builder. Reversible, because sending a new window replaces the old one, but treat it carefully in production: an end date in the past takes a live public form offline immediately and anyone visiting the link sees the not available message instead of the form. Requires the Form:Read/Write scope.

Cognito Forms: Update Entry

cognito_forms_update_entry

Change an existing entry. This is a PATCH so you only send the fields you want to change, but three of its rules bite in practice: an ARRAY must be sent whole because there is no append, setting an array to [] clears it, and setting a section or a composite field to null clears every child field underneath it. Calculation fields are recomputed and cannot be set, and file upload fields cannot be written here. The whole updated entry comes back including fields you did not touch. Reversible only in the sense that you can write the previous values back, so capture them with Cognito Forms: Get Entry first if you need to. Cognito Forms can answer HTTP 409 with Type: InvalidEntryVersion when the entry changed underneath you, in which case re-read the entry and apply the change again. Requires the Entry:Read/Write scope.

Cognito Forms: Upload File

cognito_forms_upload_file

Turn a file into a Cognito Forms file id that can be attached to an entry. Mattering downloads the bytes from the URL you give it and forwards them. This is the only way to get a file into an upload field, because Cognito Forms: Create Entry and Cognito Forms: Update Entry cannot write file contents directly: upload first and send the returned data.Id as that field's value. The id EXPIRES if it is not attached to an entry within 48 hours, which is what makes this reversible: an unused upload disappears on its own. The organization's storage limit applies and a full account answers HTTP 403 with Type: StorageLimitExceeded. Requires the Entry:Read/Write scope.

Using the integration

On the automation canvas

Cognito Forms nodes chain with every other node. A Cognito Forms webhook, configured per form in the app's submission settings, can hit a Mattering inbound webhook trigger so a workflow starts the moment somebody submits, with Cognito Forms: Get Entry fetching the full record when the payload needs enriching. A nightly schedule can drive Cognito Forms: List Entries in a View into a Mattering database. A form in another system can become a real submission through Cognito Forms: Create Entry. One value does most of the wiring: the form id from Cognito Forms: List Forms, which is a picker on every node that needs one, labelled by the form's name with its internal name underneath so two forms sharing a display name are still distinguishable.

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. Cognito Forms also publishes an MCP server of its own, and it is worth knowing about before you choose. The vendor's server is hosted, authenticated with OAuth per organization, available on the same Pro, Team and Enterprise plans, and it generates a form from a natural-language description as well as creating, reading, updating and deleting entries, retrieving documents and files, and setting form availability. Its actions consume the same monthly request allowance. For conversational work, including building a form, that is the better fit. This integration is the operations side: the same operations as steps in a workflow that runs on a schedule or a trigger with nobody present, chaining with every other connector, with the credential held once in the workspace rather than authorized per person. It also covers reading many entries through a view and bulk importing a spreadsheet with a polled status, which the assistant path does not.

Reading many entries, which goes through a view

This is the part worth reading twice. There is no list-entries endpoint on the REST API, so Cognito Forms: List Entries in a View runs against the separate OData service at a path built from a form id and a VIEW id, and the view is a grid view you built in the Cognito Forms app. The view IS the filter: the columns, the conditions and the sort you set in the app are exactly what comes back, and Cognito Forms documents only two query options on that feed, a count flag and a select. There is no filter parameter, and this integration does not offer one rather than dressing up an undocumented parameter as a supported field. Rows arrive under data.value[] with the view's own column names as properties. Three limits go with the feed: only grid views are supported, repeating-section and table-field data is excluded entirely, and values arrive in the view's export formatting, so a signature field reads as captured or not captured rather than carrying data. When you need the full record, including repeating sections and any payment order, read it individually with Cognito Forms: Get Entry.

Where a view id comes from

From the Cognito Forms app, because nothing in either of the vendor's API specifications lists views. There is no views collection, no get-view path and no views-for-a-form path, so a picker here is impossible rather than merely unbuilt. The vendor's own instruction is to copy the number out of the OData feed URL shown on the form's entries page. That is also why the picker chain in this integration stops where it does: the form field is a picker, the View field is typed, and the entry id fields are typed as well, since a dependent entry picker could only populate once a view id had already been filled in by hand. If Cognito Forms ships a views endpoint, this field gets a picker and the form picker becomes its parent.

Entry values are keyed by field name

A Cognito Forms entry is a JSON object whose property names are the form's own field names, so a downstream step reads data.Email directly and a run log is readable by a person. Composite fields such as a name or an address arrive as objects with sub-properties rather than flattened strings. Entry metadata lives under a reserved data.Entry property carrying the entry number, its status, its role, the created, submitted and updated timestamps, the admin, public, internal and reviewer links, any generated documents, and on a payment form the whole order object with amounts and billing details. Cognito Forms: Get Form Schema is still the lookup a writer wants, because it gives the exact property names, their types and their valid values, and its input mode returns only what the API will accept. One small thing to know rather than fix: a form id is declared as a string in one of the vendor's specifications and as an integer in the other, and the same is true of an entry id. Both are modelled as text here and both work, so a configuration that looks inconsistent with the vendor's docs is not broken.

Writing entries, and what PATCH does not do

Cognito Forms: Create Entry files a real submission that runs the form's own workflow, not an inert import row, and the whole entry comes back including fields you did not set. Cognito Forms: Update Entry is a PATCH, so you send only what changes, but three of its rules bite in practice: an array must be sent whole because there is no append, setting an array to empty clears it, and setting a section or composite field to null clears every child field underneath it. Read the entry first with Cognito Forms: Get Entry if you need to reconstruct anything. Two fields cannot be written by either node: calculation fields are recomputed by Cognito Forms, and upload fields have to go through Cognito Forms: Upload File first, with the returned id sent as that field's value. That id expires if it is not attached to an entry within 48 hours, which is what makes an unused upload harmless.

Bulk import, and the mode that deletes

Cognito Forms: Import Entries loads a spreadsheet or CSV that Mattering fetches from a URL you supply, and Import Mode decides everything. One mode only adds rows. One mode only updates matched rows. The syncing mode makes the form MATCH THE FILE, which means entries absent from the file are deleted, and there is no restore endpoint. That is why the node is flagged destructive even though two of its three modes are additive, and why the mode is a required field with no default: nobody should arrive at that behaviour by not choosing. The call returns an id immediately and the work happens in the background, so the outcome comes from Cognito Forms: Get Import Status rather than from the initial success. Poll it, and branch on the number of unsuccessful entries rather than on the node succeeding, because a completed import can still report failures row by row and returns a link to an annotated copy of the file explaining them.

What API requests actually cost

Two separate limits apply and they are worth keeping apart. The rate limit is 300 requests per 5 minutes, answered with HTTP 429 and a header saying when you may retry. The monthly allowance is different: 2,000 requests on Pro, 10,000 on Team and 100,000 on Enterprise, shared with the vendor's own connectors for other automation tools and its JSON webhooks rather than reserved for this integration, and billed as overage when exceeded. Neither is retried automatically here, because backoff belongs in the workflow where it is visible. The metering rule is the one that surprises people: requests are counted per 100KB, so a 150KB response counts as two. Cognito Forms: Get File and Cognito Forms: Get Document return the bytes base64-encoded inline, which makes a 5MB attachment roughly fifty requests; both also return a URL, so prefer the URL where the next step can fetch one. Large entry lists are the other expensive case, since there is no pagination anywhere in this API and a view returns its whole dataset in one response.

Entries are personal data, and often payment data

Worth stating rather than assuming, because this integration moves real submissions. An entry contains whatever the form asked a real person for: name, email address, postal address and anything else. Cognito Forms is widely used to take payment, so an entry on a payment form carries the whole order object with amounts, payment status, payment method, a confirmation number and a billing address. It is also widely used for file uploads, and Cognito Forms: Get File returns the file's actual bytes. The product is marketed for regulated use cases, so the data flowing through a workflow may be regulated too. The practical habit is simple: select the fields you need, such as data.Email, rather than forwarding a whole entry object into a chat message, a spreadsheet or an AI step's context, and be deliberate about which downstream systems a submission is allowed to reach.

What this API cannot do

Said plainly so nobody spends an afternoon looking. Forms themselves cannot be created, edited or deleted over the API, and fields and questions are built in the Cognito Forms editor; the only form-level write in the whole API is Cognito Forms: Set Public Link Availability, which opens or closes a form's public link and sets the message a visitor sees while it is closed. Views cannot be created, listed or read. There are no webhook endpoints of any kind: Cognito Forms webhooks are real and good, but they are configured per form inside the app's submission settings rather than over the API, so this integration has no webhook nodes and nothing here registers a delivery target. There is also no analytics, no folder management, no organization or user or team management, no document-template listing, and no entry comments. One vendor inconsistency to ignore: a get-form-fields operation is named in the scopes documentation and exists in neither specification, so it is not built.

Troubleshooting

A valid API key returns 401 on some nodes and works on others
This is almost always scopes rather than the key. Cognito Forms grants a Form scope and an Entry scope independently and delivers a missing scope as HTTP 401 rather than 403, with a body naming the exact scope it wanted, so read that value first. Form read covers listing forms and reading a schema; form read and write adds setting public link availability; entry read covers reading an entry, a file and a document; entry read and write adds creating and updating entries and uploading files; entry read, write and delete adds deleting an entry and the syncing mode of the import. Scopes are fixed when the key is created, so the fix is a new key with the right scopes rather than a setting to change.
Test Connection fails but entry reads work fine
That is the expected false negative rather than a fault. Test Connection calls the forms endpoint, which needs the Form read scope, so a key granted only Entry scopes fails the test while being perfectly usable for every entry node. Two ways forward: add form read to the key if you want a clean connection test and a working form picker, or accept the failing test and type form ids by hand. The picker on the form fields is sourced from Cognito Forms: List Forms, so without form read it will stay empty.
The New API Key option is not available
Either the organization is on the free Individual plan, which does not include the API, or the signed-in user is not an owner or administrator. Cognito Forms documents the API as available to organizations on the Pro, Team and Enterprise plans, so on the free plan there is no key to create and no workaround at the connector level. If the plan is right, ask an owner to create the key, since the New API Key option under Settings and Integrations is restricted to owners and administrators.
Listing entries fails, or there is nowhere to put a filter
There is no list-entries endpoint on the REST API, so bulk reads run through Cognito Forms: List Entries in a View against the OData service, and that node requires a view id as well as a form id. Build a grid view in the Cognito Forms app and copy its number out of the OData feed URL on the form's entries page. The view is where the filtering lives: Cognito Forms documents only a count flag and a select on that feed, so there is no filter parameter to set here and nothing on the node is missing. If the view exists but returns nothing useful, check that it is a GRID view, since other view types are not supported, and remember that repeating-section and table-field data is excluded from the feed entirely.
An entry read is missing data that is definitely on the form
Check which node produced it. Cognito Forms: List Entries in a View and Cognito Forms: Get Entry from a View return only the view's columns, in the view's export formatting, which is why a signature field reads as captured or not captured rather than carrying data, and they exclude repeating-section and table-field data completely. Cognito Forms: Get Entry returns the full REST entry instead, including composite field objects, repeating sections and the payment order on a payment form. The usual fix is to list ids through the view and then read each entry individually, which is also the cheaper shape under the per-100KB metering.
An update cleared fields nobody touched
That is documented PATCH behaviour rather than a fault, and it has three specific forms. An array has to be sent whole because there is no append, so sending a shorter array replaces the longer one. Sending an empty array clears it. And setting a section or a composite field to null clears every child field underneath it, which is the one that surprises people, since a name or an address is an object rather than a string. Read the entry with Cognito Forms: Get Entry before an update if you need to reconstruct anything, and send only the leaf properties you actually intend to change.
An update returns HTTP 409 about an invalid entry version
The entry changed underneath the workflow between the read and the write. Cognito Forms documents the conflict but documents no version or timestamp property on the request side, so there is no field to send and this integration cannot express optimistic concurrency; that is the vendor's shape rather than a missing feature here. The honest handling is to treat a 409 as a retry signal: re-read the entry with Cognito Forms: Get Entry, reapply the change to the current values, and write again. If a workflow hits this often, look at what else is editing the same entries at the same time, including the form's own workflow.
An import reported success but rows are missing
The initial success only means the import was accepted. The work runs in the background, so the outcome comes from Cognito Forms: Get Import Status, and a completed import can still report unsuccessful entries above zero, which is a partial success. Branch on that number rather than on the node succeeding, and follow the returned link to the annotated copy of the file, which explains the failures row by row. If rows are missing that were never in the file, check the mode: the syncing mode makes the form match the file, so anything absent from it is deleted, and there is no restore endpoint.
The monthly request allowance ran out faster than expected
Two causes, usually together. Requests are counted per 100KB rather than per call, so a large response is several requests; Cognito Forms: Get File and Cognito Forms: Get Document return bytes inline, making a 5MB attachment roughly fifty requests, and both also return a URL that a downstream step can fetch instead. And the allowance is shared rather than reserved, covering the vendor's own connectors for other automation tools and its JSON webhooks alongside this integration, so an organization already running those has less headroom than the plan's headline number. Two cheap adjustments: ask for the id column alone on Cognito Forms: List Entries in a View when you only need a list to iterate, and prefer the file URL over the inline bytes.
A call fails with an error about the form being archived or disabled
The form id is still valid but the form is no longer live. Cognito Forms: List Forms never returns archived forms, so a form id pasted into a workflow months ago can outlive its appearance in the picker, and calling anything against it fails clearly with an archived or disabled type rather than silently returning nothing. Unarchive or re-enable the form in the Cognito Forms app, or point the workflow at the current form by choosing it from the Form picker again. Cognito Forms error bodies also carry a support code, which is what its support team will ask for, so a workflow that logs failures should keep it.
A form went offline after an automation ran
Check whether Cognito Forms: Set Public Link Availability was in the path. It is reversible, because sending a new window replaces the old one, but an end date in the past closes a live public form immediately and every visitor sees the not-available message instead of the form. It is the node in this integration most able to cause visible customer impact, so gate it behind a condition or an approval step rather than a bare trigger, and double-check the timezone and the direction of the window before a scheduled run uses it.

Cognito Forms 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