A Cognito Forms MCP built around how the API actually reads entries
Connect one Cognito Forms API key and 14 nodes land on the canvas: list forms, read a form's schema, read one entry or many, create real submissions that run the form's own workflow, update and delete entries, bulk import a spreadsheet, upload files, download attachments and merged documents, and open or close a form's public link. The awkward part is listing entries, because the obvious endpoint does not exist, and this page explains what to do instead.
What the Cognito Forms MCP connector does
The Cognito Forms connector for Mattering Automations is 14 nodes across the two APIs Cognito Forms publishes: 8 reads and 6 actions. The REST API at the main host carries forms, form schemas, single entries, entry creation, update and delete, bulk import and its status, file upload and download, merged document generation and public link availability. The OData service on the same host carries reading entries in bulk. One bearer key authenticates both, and Cognito Forms sends no envelope of its own, so a node's data is the raw body: a bare array for the form list, the entry object itself for an entry read, and an OData wrapper with rows under data.value[] for entries in a view.
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can look up a form's field names with Cognito Forms: Get Form Schema, read a submission with Cognito Forms: Get Entry, and write a new one with Cognito Forms: Create Entry, which is a real submission rather than an inert import row and runs the form's own workflow exactly as if a person had filled it in.
Start with the structural fact that shapes every workflow here, because the obvious approach is the wrong one. There is no list-entries endpoint on the REST API at all. Reading many entries runs through the separate OData feed at a path built from a form id and a VIEW id, where the view is a grid view you built in the Cognito Forms app. So the view IS the filter: you set the columns, the conditions and the sort in the app, and Cognito Forms: List Entries in a View returns exactly what that view shows. Cognito Forms documents only two query options on that feed, a count flag and a select, so there is no filter parameter to pass and this page does not pretend otherwise. Three further limits on the feed are worth knowing before you design around it: only grid views are supported, the feed excludes repeating-section and table-field data, and values arrive in the view's export formatting, so a signature field reads as captured or not captured rather than carrying data. A form whose real payload lives in a repeating section has to be read one entry at a time with Cognito Forms: Get Entry.
The good news is the shape of what comes back. 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 person reading a run log can tell what they are looking at. Composite fields such as a name or an address are objects with sub-properties rather than flattened strings, and entry metadata sits under a reserved property carrying the entry number, status, role, the created and submitted and updated timestamps, the entry links, generated documents and, on a payment form, the whole order. Field-name addressing is a real advantage over form APIs that hand back opaque field ids, and it makes a Cognito Forms automation shorter, because nothing has to translate ids into meaning first.
Two commercial facts belong on this page rather than in a support ticket later. The Cognito Forms API is available on the Pro, Team and Enterprise plans; the plan that is free is called Individual and it does not include the API, so there is no free tier for anything on this page. And requests are metered in a way that catches people out: Cognito Forms counts one request per 100KB, so a large response costs more than one. That matters most on Cognito Forms: Get File and Cognito Forms: Get Document, which return the file's bytes inline in the JSON body, making a 5MB PDF roughly fifty requests rather than one. Both nodes also return a URL, so prefer the URL wherever the next step can fetch one.
One connection, three surfaces
- Visual automations. Drag Cognito Forms 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 Cognito Forms node, ready to drop on the canvas
14 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 8
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
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
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
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
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
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
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
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
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
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
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
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
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
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.
Connecting Cognito Forms takes one credential
An organization owner or administrator creates the key in Cognito Forms under Settings, then Integrations, then New API Key. You can hold several keys per integration and each one takes an expiry date or can be set never to expire. Copy it when it is shown, because Cognito Forms states plainly that a key cannot be retrieved later. Two things then decide whether a given node works. The first is the plan: Cognito Forms documents the API as available to organizations on the Pro, Team and Enterprise plans, and the free Individual plan does not include it, so a key cannot exist at all on the free plan. The second is scopes, and this is the one that generates support questions. The key form grants a Form scope and an Entry scope independently, where Form can be none, read, or read and write, and Entry can be none, read, read and write, or read and write and delete. A key that is valid but missing the scope an operation needs is answered with HTTP 401 carrying a missing-scope type and the exact scope it wanted, which is a permissions problem wearing an authentication error's clothes. Every node's description names the scope it needs. Cognito Forms also documents a query-string alternative to the header for systems that cannot send custom headers; this connector deliberately does not use it, because a credential in a URL lands in logs and referrers.
In Cognito Forms, open Settings, then Integrations, and click New API Key. You need to be an organization owner or administrator, and the organization needs to be on the Pro, Team or Enterprise plan.
Choose the Form and Entry scopes deliberately. Read-only for both is the right default; grant entry delete only if a workflow genuinely needs Cognito Forms: Delete Entry or the syncing mode of Cognito Forms: Import Entries. Set an expiry date if your policy calls for one.
Copy the key immediately. Cognito Forms does not show it again.
In Mattering Automations, open Connectors, click Add Connector, choose Cognito Forms, and create a credential with that key.
Click Test Connection. Mattering calls the forms endpoint, which takes no parameters. A pass proves the key is real, unexpired, holds the form read scope, and that the organization is on a plan that includes the API. It does not prove the entry nodes will work, because the Entry scope is granted separately, and a key granted only Entry scopes will fail this probe while being perfectly usable for entries.
All 14 Cognito Forms nodes appear in the canvas palette. Run Cognito Forms: List Forms first: it returns every reachable form with its id, name and internal name, and it is the source for the form picker on every other node.
Common uses for the Cognito Forms MCP
Route a new submission wherever the work actually happens
Cognito Forms delivers new submissions by webhook, configured per form inside the app's submission settings rather than over the API, so point one at a Mattering inbound webhook trigger and the workflow starts the moment somebody submits. From there Cognito Forms: Get Entry fetches the full entry when the payload needs enriching, and the rest is ordinary canvas work: open a task, create a CRM record, post a summary into a Mattering Comms thread, or branch on the entry status. Because values are keyed by field name, the mapping step reads data.Email rather than a lookup table of ids.
Pull a filtered view into a database on a schedule
Build the grid view you want in the Cognito Forms app, with the columns, conditions and sort that define the slice you care about, then let Cognito Forms: List Entries in a View read exactly that on a schedule into a Mattering database or a sheet. The view being the filter is a genuine advantage for a recurring report: the person who owns the report can change what it covers in the app without touching the automation. Set the select option to the id column alone when you only need a list to iterate, which is the cheap version of the call and matters because the whole dataset comes back in one response and metering counts every 100KB.
Create real submissions from another system
Cognito Forms: Create Entry does not paste a row into a table; it submits the form. The entry runs the form's own workflow, appears with the same status vocabulary as a human submission, and comes back in full including the fields you did not set. That makes it the right node for migrating an intake from somewhere else, for accepting a submission that arrived through another channel, or for letting an agent file something on a person's behalf. Read the exact property names first with Cognito Forms: Get Form Schema, and set its input mode so the schema shows only what the API will accept rather than everything a form returns.
Attach a file to an entry, which is a two-step write
Upload fields cannot be written by the create or update nodes, so a file goes in through Cognito Forms: Upload File first: Mattering fetches the bytes from a URL you give it, forwards them, and returns a file id that you then send as that field's value. The id expires if it is not attached to an entry within 48 hours, which is what makes the upload itself safe to retry, since an unused upload cleans itself up. Reading files back is the mirror image with a cost attached: Cognito Forms: Get File returns both a URL and the base64 bytes inline, and the inline bytes are what make it expensive under the per-100KB metering, so prefer the URL when the next step can fetch one.
Generate and deliver an entry's merged document
If a form has a document template behind it, Cognito Forms: Get Document produces the merged PDF or Word file for one entry, which is the receipt, agreement or summary a person expects to receive. Chain it to an email step, to a file store, or to a task so somebody signs it off. Two practical notes. Cognito Forms publishes no endpoint that lists document templates, so the template id comes from the Cognito Forms app rather than from a picker. And the response carries the bytes inline like the file read does, so the same per-100KB metering applies and a large document costs several requests.
Bulk import a spreadsheet, then check what actually landed
Cognito Forms: Import Entries takes a spreadsheet or CSV from a URL and loads it, and its mode decides everything: one mode only adds rows, one only updates matched rows, and the syncing mode makes the form MATCH THE FILE, which deletes entries that are absent from it. There is no restore endpoint, which is why the node is flagged and why the mode is a required field with no default. The call returns an id immediately and the work happens in the background, so poll Cognito Forms: Get Import Status rather than treating the initial success as the outcome. A completed import can still report unsuccessful entries above zero, so branch on that number and follow the link it returns to the annotated file explaining the failures row by row.
Example: A nightly export of a filtered view, with the expensive parts avoided
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Set up in the Cognito Forms app first: build a grid view on the form containing exactly the columns and conditions the report needs. This is where the filtering lives, so getting it right here is what keeps the automation simple.
Trigger: a nightly schedule fires.
Cognito Forms: List Entries in a View reads the view with the select option set to the id column only, which returns a list to iterate without pulling every column of every row. Only grid views work here, and repeating-section and table-field data is not included in the feed at all.
A condition compares the returned ids against what the Mattering database already holds, so only new entries continue.
Cognito Forms: Get Entry reads each new one in full, including its metadata and, on a payment form, the order details. This is also the only way to reach repeating-section data.
A transform step selects the fields the report needs by name rather than forwarding the whole entry, because an entry is a real person's submission and can carry billing details and uploaded files.
The rows land in a Mattering database, and a task opens for a person only when an entry matches the exception rule you actually care about.
Cognito Forms MCP questions, answered
How do I list all the entries on a form through the Cognito Forms API?
Not the way you would expect, and this is the question worth reading the page for. There is no list-entries endpoint on the REST API. Reading many entries runs through the separate OData service, at a path built from the form id and a VIEW id, where the view is a grid view you created in the Cognito Forms app. Cognito Forms: List Entries in a View is the node, and the view is the filter: the columns, conditions and sort you set in the app are exactly what comes back. Cognito Forms documents two query options on that feed, a count flag and a select, and nothing else, so there is no filter expression to pass and this connector does not offer one. Three limits go with it: only grid views are supported, the feed excludes repeating-section and table-field data, and values come back in the view's export formatting. For a full entry, including repeating sections and any payment order, read it individually with Cognito Forms: Get Entry.
Where does the view id come from?
From the Cognito Forms app, because no endpoint supplies it. Neither of the vendor's two API specifications has a views collection, a get-view path, or a views-for-a-form path, so nothing can list them. The vendor's own instruction is to copy the number out of the OData feed URL shown on the form's entries page in the app. That is also why the form field on these nodes is a picker while the view field is typed: the picker chain is broken at the view by the API rather than by the connector, and a dependent entry picker underneath it would have been empty for exactly the people who needed it most. If Cognito Forms ever ships a views endpoint, this field gets a picker and the form picker becomes its parent.
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 use them. Matter, the assistant built into the platform, uses the same nodes natively. Because entry values are keyed by the form's own field names, an assistant reading an entry gets readable property names rather than opaque ids, which makes this a comfortable surface for an agent. Keep the delete and import nodes out of that toolset: an entry is somebody's real submission and there is no restore endpoint.
Cognito Forms ships its own MCP server. Why use this connector?
It does, and for some jobs its server is the better answer, so use it where it fits. Cognito Forms runs a hosted MCP server, documented on its own support site, authenticated with OAuth per organization and available on the same Pro, Team and Enterprise plans. It generates a form from a natural-language description, creates, reads, updates and deletes entries, retrieves documents and files, and sets form availability, and its actions consume the same monthly API request allowance yours would. If what you want is an assistant that can look things up and build a form for you in conversation, that is the right tool. This connector is a different shape: the same operations as steps on an automation canvas that runs on a schedule or a trigger with nobody present, chaining with every other connector in one workflow, with the credential held once in a shared workspace store rather than authorized per person, and with the destructive nodes flagged so you can gate them. It also reaches things the assistant path does not, notably reading many entries through a view and bulk importing a spreadsheet with a polled status.
Do I need a paid Cognito Forms plan to use this?
Yes. Cognito Forms documents the API as available to organizations on the Pro, Team and Enterprise plans, and the plan that is free is called Individual, which does not include it. There is no free tier for anything on this page, and the API key form is simply not available on the free plan, so this is a hard gate rather than a reduced allowance. Worth checking one level deeper before you plan capacity: the monthly request allowance differs by plan, at 2,000 requests a month on Pro, 10,000 on Team and 100,000 on Enterprise, and it is SHARED rather than reserved, covering the Cognito Forms API alongside the vendor's own connectors for other automation tools and its JSON webhooks. An organization already running integrations off the same account has less headroom than the headline number suggests, and exceeding the allowance is billed as overage. Confirm the current figures on Cognito Forms' own pricing and integration pages before committing to a volume.
Why does a valid API key return 401?
Because scopes are granted separately from validity, and Cognito Forms delivers a missing scope as a 401 rather than a 403. The key form has two independent scopes: a Form scope, which can be none, read, or read and write, and an Entry scope, which can be none, read, read and write, or read and write and delete. The error body names the exact scope it wanted, so read that first. Reading forms and schemas needs form read; setting public link availability needs form read and write; reading an entry, a file or a document needs entry read; creating and updating entries needs entry read and write; deleting an entry, and the syncing mode of the import, need entry read and write and delete. The false negative is worth knowing too: a key granted only entry scopes will fail the connection test, which reads forms, while being perfectly usable for every entry node.
How is API usage counted, and what makes a call expensive?
Cognito Forms counts requests in 100KB units rather than per call: it documents that a 150KB request counts as two and a 400KB request counts as four. Most calls are one request, but two nodes are not. Cognito Forms: Get File and Cognito Forms: Get Document return the file's bytes base64-encoded inline in the JSON body, so a 5MB attachment is roughly fifty requests out of the month's allowance. Both responses also carry a URL, so prefer the URL whenever the next step can fetch one. A very large entry list is the other place this bites, since there is no pagination anywhere in this API and a view returns its whole dataset in one response; asking for the id column alone is the cheap way to iterate. Separately from the monthly allowance there is a rate limit of 300 requests per 5 minutes, answered with HTTP 429 and a header saying when to retry, which is not the same thing as running out of allowance.
Can it create and delete entries, or only read them?
All four, and this is where Cognito Forms differs from the read-mostly form APIs. Cognito Forms: Create Entry files a real submission that runs the form's own workflow. Cognito Forms: Update Entry patches an existing one, with three rules that bite: 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. Cognito Forms: Delete Entry removes a submission along with its uploaded files and any payment record attached to it, with no restore endpoint anywhere, which is why it is flagged and why it needs a scope nobody has by accident. Cognito Forms: Import Entries can do all three in bulk, and its syncing mode deletes anything absent from the file. What the API cannot do is edit forms: fields and questions are built in the Cognito Forms editor, and the only form-level write in the whole API is Cognito Forms: Set Public Link Availability. Webhooks are configured per form inside the app rather than over the API, so there are no webhook nodes here.
Put Cognito Forms 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. Cognito Forms is a product of its respective owner; Mattering is an independent platform.