# Cognito Forms MCP MCP

> Cognito Forms MCP connects your AI client directly to your online form data, giving you full control over submissions and forms. Use natural conversation to list active forms, retrieve specific entry details, search past submissions, or even create new records instantly. It manages all your structured data collection workflows without needing to open the portal.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** form-builder, data-collection, conditional-logic, workflow-automation, submission-management, validation

## Description

Managing forms and collecting data shouldn't mean opening a web portal and clicking through menus. This MCP lets you talk to your form data directly from any AI client. You can ask your agent to list every active form or pull up all submissions for a specific project, getting detailed metadata on the fly. It’s like having an analyst sitting next to you who knows exactly where every single piece of submitted information lives.

Need to find that lead from three months ago? Your agent uses `search_entries` to pinpoint it instantly. Want to build a new record right now? You use `create_entry`. Even better, if you're working with developers, your agent can pull the full JSON schema using `get_form` so they know exactly what fields need validation. It’s all about getting data out of isolated forms and into your workflow. This makes it a core piece of infrastructure for any team that relies on structured intake—especially when connected via Vinkius' catalog.

## Tools

### check_cognito_status
Verifies the connection status between your AI client and the Cognito Forms platform.

### create_entry
Generates a completely new form submission record with specific field values.

### delete_entry
Permanently removes a specified form entry from your data records.

### get_entry
Retrieves all the detailed information for one specific, known form submission.

### get_form_fields
Retrieves a list of all individual fields and their properties within a specified form.

### get_form
Pulls the full JSON schema definition for a particular form to understand its structure.

### list_entries
Fetches a paginated list of recent or filtered entries across your forms.

### list_forms
Provides an inventory of all the form projects you currently have set up in Cognito Forms.

### list_organizations
Lists all organizational accounts or groups connected to your main Cognito account.

### list_templates
Gets a list of available form templates you can use as starting points for new projects.

### search_entries
Searches all entries using keywords or specific criteria to find historical data.

### update_entry
Modifies the values of an existing form submission record.

## Prompt Examples

**Prompt:** 
```
List all active forms in my Cognito account.
```

**Response:** 
```
I've retrieved your forms. You currently have 3 active projects: 'Customer Support' (ID: support-v1), 'Sales Intake', and 'Feedback Survey'. Which one would you like to see the entries for?
```

**Prompt:** 
```
Show the last 5 entries for the 'Sales Intake' form.
```

**Response:** 
```
Fetching entries... I found 5 recent submissions for 'Sales Intake'. Highlights include a new lead from @user1 and a pricing inquiry. Would you like the detailed field values for the latest lead?
```

**Prompt:** 
```
Get the JSON schema for form ID 'feedback-survey'.
```

**Response:** 
```
I've retrieved the schema for 'feedback-survey'. The form expects 4 main fields: 'Rating' (Numeric), 'Comments' (Long Text), 'Email', and 'SubmitDate'. I'm ready to create a new entry for you.
```

## Capabilities

### Get an overview of existing forms
List all active or archived online forms to see what data collection projects you have running.

### Retrieve specific submission details
Fetch the full, detailed information for any single form entry using its ID and metadata.

### Identify required form fields
Access the complete JSON schema for a form to understand exactly what data structure is expected, including validation rules.

### Inject new records into forms
Programmatically create brand-new entries (like submitting a test lead) using structured input from your AI client.

### Track and modify submissions
Update existing form entries, or delete old data, keeping your records accurate without manual intervention.

## Use Cases

### Need to audit old client feedback
A data analyst needs to know if a specific complaint mentioned six months ago was ever resolved. They ask their agent, and it runs `search_entries` across all forms, pulling up the exact record ID and context for review.

### New lead comes in via chat
A sales team member gets a quick inquiry from social media. Instead of forcing them to manually fill out a form, they ask their agent to use `create_entry`, passing the name and inquiry details directly into the system.

### Validating input for custom scripts
A developer is building an external data ingestion script. They run `get_form` first, which provides the schema so their code knows exactly what fields are required and if they must be numeric or text.

### Checking overall form health
An operations manager needs to know how many forms are currently active. They run `list_forms` to get an instant count, confirming that all necessary data collection methods are operational.

## Benefits

- Stop exporting to spreadsheets. Instead of manually downloading entries, your agent uses `list_entries` and `search_entries` to give you structured reports instantly.
- You never have to guess what fields exist. Using `get_form` provides the full JSON schema definition so your AI client knows exactly how data is structured before it starts writing or validating anything.
- Speed up lead capture cycles by using `create_entry`. Instead of having a human type in details, you can pass all the required variables to your agent for immediate submission.
- Maintain clean, accurate records. If a piece of information changes (like an address), use `update_entry` through the MCP instead of manually logging into the form builder and making edits.
- See what's available immediately by using `list_forms`. You get a full inventory of every project you own without clicking around in the backend portal.

## How It Works

The bottom line is you get to manage complex form operations using simple chat commands instead of navigating dashboards.

1. Subscribe to this MCP on Vinkius and grab your API Token from Cognito Forms settings.
2. Connect that token to your preferred AI client (Claude, Cursor, etc.).
3. Tell your agent what you need—for example, 'List all active forms.' The agent calls the tool, retrieves the data, and presents it back in conversation.

## Frequently Asked Questions

**How do I list all my active forms using Cognito Forms MCP?**
You simply tell your agent to run `list_forms`. It will provide a complete inventory of every form project you have access to, so you know exactly what data streams are available.

**What is the difference between list_entries and search_entries?**
`List entries` fetches recent submissions in bulk. `Search entries`, however, allows you to query specific keywords or criteria across historical records, helping you pinpoint older data fast.

**Can I use Cognito Forms MCP to add a new lead manually?**
Yes. You can use the `create_entry` tool by providing all the necessary field values and metadata through your AI client's conversation, simulating a manual form submission.

**Do I need to know the exact ID to update data?**
Yes. To modify existing records using `update_entry`, you must first have the specific entry ID and the new values for that record.

**What is the best way to understand a form's requirements using get_form?**
You use `get_form` to retrieve the complete JSON schema for any form. This tells your agent exactly what data types, field names, and validation rules a form expects, letting you build accurate submissions or checks before creating an entry.

**Can I use delete_entry to remove old or incorrect records?**
Yes, your agent handles deletion directly via `delete_entry`. You provide the specific entry ID and confirmation, allowing you to clean up outdated or erroneous records without manually logging into the portal.

**Should I run check_cognito_status first when setting up my connection?**
Running `check_cognito_status` confirms your connectivity right out of the gate. It immediately verifies that your API token and credentials are valid, saving you time debugging setup issues later on.

**How do I see all the different organizations I manage with list_organizations?**
Running `list_organizations` shows every organizational account you have access to within Cognito Forms. This is critical when your data spans multiple departments or client accounts, helping you select the correct scope for subsequent commands.

**How do I find my Cognito Forms API Key?**
Log in to your account, navigate to **Organization Settings** > **API Tokens**, and generate a new token for the REST API.

**Can I retrieve the schema for a form via AI?**
Yes! The `get_form_schema` tool retrieves the complete JSON definition of your form, including field types and validation rules.

**How do I create a new entry programmatically?**
Use the `create_entry` tool and provide a JSON string containing the data for the fields defined in your form's schema.