Connect Google Forms to Claude: Browse Forms and Inspect Submissions

If you need to connect Google Forms to Claude to automate survey analysis, audit form configurations, or trigger workflows based on user submissions, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and the Google Forms REST API. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Google Forms to ChatGPT or explore our broader architectural overview on connecting Google Forms to AI Agents.

Giving a Large Language Model (LLM) read access to a sprawling data ecosystem like Google Workspace is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Google's strict API quotas. Every time Google updates an endpoint or changes its authorization scopes, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Google Forms, connect it natively to Claude, and execute complex workflows using natural language.

The Engineering Reality of the Google Forms API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Google APIs is painful. You are not just integrating "Google Forms" - you are integrating a highly nested, specific data model that relies on other Google Workspace APIs to function completely.

If you decide to build a custom MCP server for Google Forms, you own the entire API lifecycle. Here are the specific challenges you will face:

The Split Between Forms and Drive APIs To list the Google Forms a user has access to, you cannot simply query a GET /forms endpoint. The Google Forms API does not have a native "list" method for forms. Instead, you must query the Google Drive API, filtering the request by mimeType = 'application/vnd.google-apps.form'. Your MCP server must handle authentication scopes for both Google Drive (to discover the forms) and Google Forms (to read the form structure and responses). An LLM has no context on this underlying service boundary; it just wants to call a list_all_forms tool.

Deeply Nested Form Schemas The Google Forms API represents a form as a deeply nested JSON object. An item on a form is not just a simple question. It is an Item object, which contains a QuestionItem, which contains a Question, which might contain a ChoiceQuestion or a GridQuestion, which then contains Options. Passing this raw, deeply nested structure directly to an LLM without strict JSON Schema enforcement results in hallucinations. The LLM needs a strictly defined MCP tool schema to understand where the actual question text lives versus the structural metadata.

Decoupled Question and Response Architectures Google Forms separates the form structure from the user submissions. When you fetch a form response, the payload does not contain the question text. Instead, it contains an array of answers keyed by a system-generated questionId.

{
  "answers": {
    "1a2b3c4d": {
      "questionId": "1a2b3c4d",
      "textAnswers": {
        "answers": [{"value": "I loved the product features."}]
      }
    }
  }
}

To make sense of this response, the LLM must first fetch the form structure, memorize the mapping of questionId to human-readable question text, and then fetch the responses to map the text answers back to the original questions. Your MCP tools must be designed to facilitate this multi-step lookup pattern effortlessly.

How Truto's MCP Server Fixes the Integration Gap

Instead of writing custom JSON-RPC handlers for every Google Forms endpoint, Truto dynamically generates MCP tools based on the API documentation and schemas of the underlying integration. When you connect a Google account to Truto, the platform creates an authenticated environment.

When Claude connects to the Truto MCP URL, Truto inspects the Google Forms API definitions and presents them as flattened, cleanly described tools (like get_single_form_by_id). Truto handles the OAuth token refresh lifecycle, the pagination normalization, and the underlying REST requests.

Handling Google Forms API Rate Limits

Google APIs enforce strict usage quotas and rate limits. It is critical to understand how this is handled in an AI agent architecture. Truto does not retry, throttle, or apply backoff on rate limit errors.

When the upstream Google API returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to Claude via the MCP protocol. However, Truto normalizes the upstream rate limit information into standardized HTTP headers per the IETF specification:

• ratelimit-limit
• ratelimit-remaining
• ratelimit-reset

The caller (in this case, Claude or your orchestrating framework like LangChain) is responsible for reading this error, inspecting the reset time, and applying the appropriate retry or backoff logic. Truto does not artificially absorb these limits or cache Google Forms data to circumvent them.

sequenceDiagram
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Google as Google Forms API

    Claude->>Truto: Call Tool: list_all_forms_responses
    Truto->>Google: GET /v1/forms/{id}/responses
    Google-->>Truto: HTTP 429 Too Many Requests<br>(Retry-After: 60)
    Truto-->>Claude: JSON-RPC Error: 429 Too Many Requests<br>Headers: ratelimit-reset
    Note over Claude: Claude must wait 60s<br>before retrying the tool

Step 1: Generating the Google Forms MCP Server

To connect Claude to Google Forms, you first need to generate a secure MCP server URL scoped to your specific Google account. Truto provides two ways to do this: through the dashboard UI or programmatically via the API.

Method A: Via the Truto UI

For ad-hoc analysis or quick setups, generating the server through the dashboard is the fastest path.

1. Log in to your Truto dashboard and navigate to the Integrated Accounts page.
2. Locate the connected Google account you want to grant Claude access to.
3. Click into the account details and select the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict methods to read only, or filter by specific tags if available).
6. Click Generate and securely copy the resulting MCP server URL (e.g., https://api.truto.one/mcp/abc123def456).

Method B: Via the API

If you are building an AI agent product and need to provision MCP servers for your users programmatically, you can hit the Truto REST API. This is ideal for multi-tenant applications where every user gets their own sandboxed MCP endpoint.

Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Google Forms Analysis Server",
    "config": {
      "methods": ["read", "list"]
    }
  }'

The API will return a payload containing the url for the newly created MCP server. This tokenized URL is fully self-contained and handles the authentication to Truto automatically.

Step 2: Connecting the MCP Server to Claude

Once you have your Truto MCP server URL, you must register it with your Claude client. You can do this either through the UI (if using a supported platform) or by manually editing the configuration file for Claude Desktop.

Method A: Via the Claude UI

If you are using Claude for Work (Team or Enterprise plans), you can add custom connectors directly in the interface.

1. Open Claude and navigate to Settings -> Integrations (or Connectors depending on your plan).
2. Click Add MCP Server or Add custom connector.
3. Paste the Truto MCP Server URL you generated in Step 1.
4. Save the configuration. Claude will instantly perform a handshake with the URL, fetch the available tools, and make them available in your chat sessions.

Method B: Via Manual Config File (Claude Desktop)

If you are running Claude Desktop locally, you will use the Server-Sent Events (SSE) proxy to connect the remote Truto URL to your local client.

Open your claude_desktop_config.json file. Depending on your OS, this is usually found at:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the Truto MCP server using the @modelcontextprotocol/server-sse package to proxy the connection:

{
  "mcpServers": {
    "google-forms-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_GENERATED_TOKEN"
      ]
    }
  }
}

Restart Claude Desktop. The application will initialize the server, read the Google Forms API documentation records stored in Truto, and dynamically build the tool schemas.

Hero Tools for Google Forms

Truto exposes the underlying Google Forms (and necessary Drive) endpoints as fully typed MCP tools. Here are the highest-leverage tools available for your AI agents.

get_single_form_by_id

This tool retrieves the full structure, title, description, and item hierarchy of a specific Google Form. Because of the deeply nested schema, Claude uses this tool to map out exactly what questions are on the form, the types of questions (e.g., text, radio, grid), and the internal questionId strings required to decipher user responses.

"Fetch the structure for the Google Form with ID '1abc...'. Give me a summarized list of all the questions, their required status, and note their internal question IDs so we can map responses later."

list_all_forms

This tool queries the Google Drive API under the hood, filtering for the specific MIME type associated with Google Forms. It returns an array of file objects representing forms accessible to the authenticated user, including the form's id, name, and ownership details.

"Search my connected Google account for all available Google Forms. List their titles and their IDs in a markdown table so I can decide which one to analyze."

list_all_forms_responses

This tool fetches all the user submissions for a specific Google Form. It handles the pagination to return the array of form response objects. Because the responses contain questionId references rather than raw text, Claude will typically need to use this in tandem with get_single_form_by_id.

"Get all the responses for the Customer Feedback form (ID: '1xyz...'). I need to extract the raw data, but wait until I have the form structure so we can map the IDs to actual questions."

get_single_forms_response_by_id

When you need to drill down into a specific user's submission - perhaps triggered by a webhook or an escalated support workflow - this tool retrieves the full details of a single form response based on the form_id and the response id.

"Pull the specific form submission with response ID 'resp-9876' from the Onboarding Survey form. Map the answers to the questions and summarize the user's feedback."

list_all_oauth_user_info

This utility tool fetches the basic profile information of the currently authenticated Google user. It returns the user's unique identifier (sub), full name, email address, and profile picture URL. This is critical for agents operating in multi-tenant environments to verify whose data they are currently querying.

"Check the currently authenticated user profile for this Google connection. Tell me which email address we are operating under before we start extracting form data."

To view the complete inventory of available tools, required arguments, and JSON schemas for Google Forms, visit the Truto Google Forms integration page.

Workflows in Action

When Claude is equipped with these MCP tools, it can perform complex, multi-step operations that would traditionally require custom scripts, hardcoded API mapping, and manual data exports.

Workflow 1: Auditing Form Configurations and Bias

User research teams often create massive surveys with complex routing and branching logic. Before deploying a survey, you can instruct Claude to audit the form's structure for clarity, leading questions, or configuration errors (like forgetting to mark a critical field as required).

"Find the 'Q3 Product Feedback' form in my account. Retrieve its full structure and audit all the questions. Flag any questions that seem biased or leading, and list any questions that should probably be marked as 'required' but aren't."

How the agent executes this:

1. Claude calls list_all_forms to search the account's drive and finds the form named "Q3 Product Feedback", noting its id.
2. Claude calls get_single_form_by_id passing the id to retrieve the massive, nested JSON structure.
3. Claude parses the items array, evaluating the QuestionItem properties against its internal heuristics for bias.
4. Claude generates a report detailing which question texts are leading, and points out specific questionId blocks that are missing the required: true flag.

Workflow 2: Extracting and Summarizing NPS Feedback

Analyzing open-ended text responses in Google Forms usually involves exporting a CSV, importing it into an analytics tool, and running sentiment analysis. With Truto and Claude, the agent can map the data relationships dynamically and generate the analysis in real-time.

"I need an analysis of the 'Post-Webinar NPS' form. Fetch the form to understand the questions, then fetch all the responses. Map the text answers to the 'What could we improve?' question, run a sentiment analysis on them, and give me the top 3 themes."

How the agent executes this:

flowchart TD
    A["Claude Tool Call<br>list_all_forms"] --> B["Extract Form ID<br>for 'Post-Webinar NPS'"]
    B --> C["Claude Tool Call<br>get_single_form_by_id"]
    C --> D["Identify questionId<br>for 'What could we improve?'"]
    D --> E["Claude Tool Call<br>list_all_forms_responses"]
    E --> F["Extract answers matching<br>the target questionId"]
    F --> G["Run Sentiment Analysis<br>Generate Summary"]

1. Claude calls list_all_forms to locate the target form ID.
2. Claude calls get_single_form_by_id to download the schema. It scans the items array to find the text "What could we improve?" and memorizes its internal questionId (e.g., 0a1b2c).
3. Claude calls list_all_forms_responses to pull the submission data.
4. Claude iterates over the responses, looking specifically at answers.0a1b2c.textAnswers.answers.
5. Claude performs the requested sentiment analysis on the extracted text values and presents the top 3 themes to the user.

Security and Access Control

When granting AI agents access to survey data and user submissions, security is paramount. Truto provides several layers of access control built directly into the MCP token architecture:

• Method Filtering: You can restrict a server to specific operational categories using config.methods. Passing ["read"] ensures the agent can only execute get and list tools, preventing accidental data modification.
• Tag Filtering: Limit the surface area by passing config.tags during server creation. If you only want the agent to access forms metadata but not the responses, you can filter tools by specific tags defined in the integration.
• Time-to-Live (TTL): Set an expires_at ISO datetime when creating the MCP server. Truto stores this in a Cloudflare KV entry and schedules a Durable Object alarm to automatically tear down the server and purge the token when the time expires.
• Extra Authentication Layer: By default, possession of the MCP URL grants access. For higher security, set require_api_token_auth: true. This forces the MCP client to also pass a valid Truto API token via the Authorization header, preventing unauthorized access if the URL leaks.

Wrapping Up

Connecting Google Forms to Claude via a managed MCP server eliminates the boilerplate of OAuth flows, Drive API discovery quirks, and JSON mapping. By giving Claude direct, schema-aware access to your forms and submissions, you unlock the ability to audit survey logic, map relational IDs, and analyze qualitative data entirely through natural language.

Whether you are building internal agentic workflows to monitor product feedback, or embedding AI analysis directly into your SaaS application, Truto's dynamic tool generation provides the abstraction layer needed to scale safely.