# Google Forms MCP

> Google Forms MCP Server lets you read and analyze your Google Forms data directly through chat. List active forms, check their structure, and pull raw answers and aggregate insights from all recent submissions. It handles data collection and survey analysis without needing to download CSVs or dig into charts.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** data-collection, survey-analysis, response-tracking, form-automation, data-extraction

## Description

This Google Forms MCP Server lets your AI client read and analyze your Google Forms data straight through the chat. You won't need to download CSVs or mess with charts. You just chat with your form data.

To start, you can pull a list of active forms using the `list_forms_by_id` tool, which retrieves all Google Forms associated with a given file ID. You can then check the structure and metadata of any specific form with the `get_form_metadata` tool; this inspects the schema so you know exactly what questions your team asked. When you're ready for the data, the `get_form_responses` tool pulls every recorded answer and data payload from a specific form. It gives you all the raw answers and the aggregate insights from recent submissions.

## Tools

### get_form_metadata
Retrieves the structure and metadata (schema) of a specific Google Form.

### get_form_responses
Pulls all recorded answers and data payloads from a specific Google Form.

## Prompt Examples

**Prompt:** 
```
Read the form metadata and structure for the Form ID 'abc123xyz'.
```

**Response:** 
```
I've fetched the structure. The active Form is titled 'Post-Event Feedback 2024'. It contains 4 explicit questions, including 'Rate your experience (1-10)' and 'Freeform Comments'.
```

**Prompt:** 
```
Fetch the responses recorded today in the Sales Survey (Form ID abc). Summarize the general satisfaction.
```

**Response:** 
```
I've captured 22 recent responses. Across those payloads, the prevalent satisfaction score hovers between 8 and 9. Top positive highlight: 'Fast customer service'. Negative outliers point out a lack of documentation.
```

**Prompt:** 
```
List all active form instances under my account to find the latest specific quiz run.
```

**Response:** 
```
Search initialized. Under your root index I discovered two forms matching normal schemas: 'Marketing Q1 Trends' (ID 4122) and 'Staff Quiz Baseline' (ID 198a). Which one should I focus on?
```

## Capabilities

### List active forms by ID
Retrieves a list of Google Forms associated with a given file ID.

### Get form structure
Inspects the schema and metadata of a specific Google Form.

### Fetch all form responses
Pulls all submitted answers and data payloads for a specific Google Form.

## Use Cases

### Figuring out what questions were asked.
The marketing team is worried about a new survey's scope. Instead of manually opening the form and reading the question list, they ask the agent to use `get_form_metadata` on the Form ID. The agent returns the full structure, confirming the form contains 'Rate your experience (1-10)' and 'Freeform Comments'—exactly what they needed.

### Summarizing post-event feedback.
An event coordinator needs to know the general sentiment from 300 attendees. They prompt the agent to run `get_form_responses` for the event ID. The agent processes the raw data and summarizes that the 'Fast customer service' was the top positive highlight, while 'lack of documentation' were the main negative outliers.

### Finding the right form ID for a quiz.
A developer needs to analyze a quiz run last month, but there are dozens of forms. They ask the agent to list all active forms. The agent uses the listing tool to return two matching schemas, allowing the developer to select the correct Form ID for deep data analysis.

### Extracting specific attendee confirmations.
An event planner needs to verify if a specific attendee, 'Jane Doe' (ID 99), actually submitted their confirmation. They ask the agent to run `get_form_responses` filtered by the attendee ID. The agent pulls the raw answers, confirming the exact details submitted by that individual.

## Benefits

- See NPS score trends without diving into raw data. The agent summarizes complex responses from `get_form_responses`, giving you immediate insights instead of a massive CSV file.
- Validate survey questions on the fly. Use `get_form_metadata` to instantly check a form's schema, confirming exactly which questions your team is querying before you write a single line of code.
- Process submissions across multiple forms. You can list all active forms using the server's capabilities, making sure you don't miss a crucial survey running under a different file ID.
- Get raw data and insights instantly. `get_form_responses` pulls the full answer payload for a form, allowing your AI client to summarize everything from text comments to multiple-choice selections.
- Reduce manual data handling. You bypass the process of downloading, opening, and cleaning up multiple CSV sheets. The data streams directly into your chat window for immediate use.

## How It Works

The bottom line is that your AI client handles the connection, so you just talk to it about your form data.

1. 1. Subscribe to the server hook and authorize it via OAuth 2.0 pointing to Google Workspace.
2. 2. Use the agent to execute advanced read commands, querying your form matrix.
3. 3. The agent reads the form metadata or response data and streams the results back into the chat environment.

## Frequently Asked Questions

**How do I use the Google Forms MCP Server to list all my forms?**
You tell the agent to list all active forms. This uses the server's form aggregation capability to pinpoint all surveys running under your account, regardless of which folder they are in.

**Does the Google Forms MCP Server summarize data automatically?**
Yes. You request a summary (e.g., 'Summarize general satisfaction') and the agent processes the raw data pulled by `get_form_responses`, giving you aggregated insights immediately.

**What does `get_form_metadata` actually return?**
It returns the form's schema. This lets you see the form's title, how many questions it has, and the exact field names and types (e.g., 'Rate your experience (1-10)').

**Can I filter responses by a specific date range using Google Forms MCP Server?**
Yes. You can prompt the agent to fetch responses recorded within a specific date range, ensuring you only analyze the data relevant to your current project or event.

**How do I use `get_form_responses` to get responses for a specific form ID?**
You pass the Form ID directly to the function. This retrieves all recorded answers for that specific survey. The result includes timestamps, individual question answers, and the submission payload.

**What credentials do I need for the Google Forms MCP Server?**
You must authorize the server using a Google Workspace OAuth 2.0 flow. This grants your agent read-only access to your Google Forms data. Never share your raw credentials.

**Does `get_form_metadata` handle forms that are private or archived?**
The function only reads metadata for active forms. If a form is deleted or archived, the API will return an appropriate error code, telling you it's inaccessible.

**What happens if I run `get_form_responses` for a very large number of submissions?**
The server handles large payloads by paginating the results. You'll receive data in manageable chunks, and the agent will process all records until the end of the dataset is reached.

**Can this server physically create a new Google Form from scratch using instructions?**
No. Google Forms API capabilities prioritize analytical reading of existing surveys (pull responses, list metadata). Destructive changes or creation matrices are not optimized here.

**Do I need any specific permission boundaries on Google SDKs to extract data?**
You strictly need the 'googleapis.com/auth/forms.responses.readonly' and 'forms.body.readonly' scopes toggled via cloud. The system operates purely in minimal ReadOnly mode.

**Is pagination natively supported when I pull thousands of responses?**
Yes. Due to Vurb core Egress controls, any call against a hyper-populated response matrix will logically paginate into manageable blocks ensuring stability across agents without truncating context loss.