Connect Google Meet to Claude: Access Participants and Records

If your team needs to connect Google Meet to Claude to automate meeting summaries, analyze transcripts, or audit participant attendance, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and the Google Workspace 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 Meet to ChatGPT or explore our broader architectural overview on connecting Google Meet to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling enterprise ecosystem like Google Workspace is a severe engineering challenge. You have to handle Google's strict OAuth 2.0 token lifecycles, manage restricted API scopes, map deeply nested JSON schemas to MCP tool definitions, and deal with Google Meet's specific data hierarchy. Every time Google updates an endpoint or changes a resource structure, 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 Meet, connect it natively to Claude Desktop, and execute complex meeting workflows using natural language.

The Engineering Reality of the Google Meet 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 over JSON-RPC, implementing it against Google's REST APIs is painful. Google Meet is not a simple flat CRUD application; it relies on complex, hierarchical resource relationships.

If you decide to build a custom Google Meet MCP server, here are the specific integration challenges you will face:

Deeply Nested Resource Hierarchies The Google Meet API structure mandates that you know the parent resource to fetch the child resource. You do not just fetch "all transcripts." A space contains conference records. A conference record contains participants and transcripts. A transcript contains transcript entries.

To read a single sentence spoken in a meeting, an LLM must navigate: spaces/{space}/conferenceRecords/{conferenceRecord}/transcripts/{transcript}/entries/{entry}. If your MCP tools do not clearly enforce these required parent IDs in their JSON Schema definitions, the LLM will hallucinate IDs or attempt to pass invalid query structures, resulting in HTTP 400 errors.

Asynchronous Artifact Generation When a Google Meet conference ends, the conferenceRecord object is created immediately. However, the associated artifacts - transcripts and recordings - are generated asynchronously. They might not be available for several minutes or hours depending on the length of the meeting. An LLM attempting to immediately extract action items from a meeting that just ended will encounter an empty list when querying the transcripts endpoint. Your integration logic must account for this delay rather than assuming data parity upon meeting completion.

Rate Limits and Quotas Google Workspace imposes strict quota limits on API requests per minute per project and per user. When these limits are exceeded, Google returns an HTTP 429 Too Many Requests response.

Note on Truto's architecture: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Google API returns an HTTP 429, Truto passes that exact error to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (or the AI framework driving the agent) is entirely responsible for implementing retry logic and exponential backoff.

Step 1: Generate the Google Meet MCP Server

Truto dynamically generates MCP tools from the integration's resource definitions and documentation. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM only sees high-quality, well-defined endpoints.

You can generate the MCP server URL in two ways.

Method A: Via the Truto UI

For administrators setting up an internal agent, the UI is the fastest path:

1. Log into your Truto account and navigate to the Integrated Accounts page.
2. Select the connected Google Meet account you want to use.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read-only methods).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/abc123def456...).

Method B: Via the API

For developers embedding AI features into their own software, you can programmatically generate the MCP server for a specific tenant's integrated account.

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

curl -X POST https://api.truto.one/api/integrated-account/<INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Google Meet Agent Access",
    "config": {
      "methods": ["read"]
    }
  }'

The API validates the configuration, generates a secure cryptographic token, stores the metadata, and returns the endpoint URL:

{
  "id": "mcp_srv_89012",
  "name": "Google Meet Agent Access",
  "config": { "methods": ["read"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

This URL is self-contained. It encodes the specific Google Meet account, the allowed methods, and the authentication token.

Step 2: Connect the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude takes seconds. Because communication happens over standard HTTP POST with JSON-RPC 2.0 messages, the client does not need to handle OAuth handshakes - the Truto URL handles the underlying Google Meet authentication automatically.

Method A: Via the Claude UI

If you are using the Claude Desktop application or an enterprise UI like ChatGPT:

1. In Claude Desktop, navigate to Settings -> Integrations -> Add MCP Server.
2. (If using ChatGPT, go to Settings -> Apps -> Advanced settings -> Custom connectors).
3. Enter a name for the connection (e.g., "Google Meet via Truto").
4. Paste the Truto MCP server URL into the endpoint field.
5. Click Add or Save.

Claude will immediately send an initialize request to the server, discover the available Google Meet tools, and populate its internal context.

Method B: Via manual config file

If you prefer to configure Claude Desktop manually, you can edit the claude_desktop_config.json file. Truto MCP servers operate over standard HTTP/SSE.

Update your configuration file to use the official MCP SSE transport tool:

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

Restart Claude Desktop. The application will boot the SSE client, connect to the Truto URL, and synchronize the tool list.

Security and Access Control

Giving an LLM unconstrained access to a company's meeting records is a severe security risk. Truto provides four distinct configuration flags to restrict the MCP server's blast radius:

• Method Filtering: Pass config.methods: ["read"] to ensure the agent can only execute GET or LIST operations, preventing it from accidentally altering records.
• Tag Filtering: Use config.tags to limit tool exposure to specific domains. If you only want the agent to see transcript data, you can exclude administrative user endpoint tools entirely.
• Require API Token Auth: By setting config.require_api_token_auth: true, possession of the MCP URL is no longer sufficient. The caller must also pass a valid Truto API token in the Authorization header, providing a strict second layer of identity verification.
• Expiration (Time-to-Live): Use expires_at to create temporary, short-lived MCP servers (e.g., granting an auditing agent access to meeting records for exactly 24 hours).

Hero Tools for Google Meet

The Truto Google Meet MCP server exposes a carefully curated set of endpoints. By deriving these tools directly from integration documentation and JSON schemas, the LLM receives exact instructions on which parameters are required, preventing hallucinated API calls.

Here are 6 high-leverage tools available for Google Meet workflows.

list_all_meet_conference_records

Fetches a paginated list of conference records associated with the authenticated user. This is the starting point for almost all Google Meet AI workflows, providing the baseline IDs required for subsequent calls.

"Find the conference records for the meetings I hosted yesterday and list their unique IDs."

get_single_meet_conference_record_by_id

Retrieves the detailed metadata for a specific conference record. It returns the exact start time, end time, and the underlying space name associated with the meeting.

"Look up the metadata for conference record ID 'MTR-893-X' and tell me exactly how long the meeting lasted."

list_all_meet_conference_record_participants

Returns an array of participant objects for a specific conference. Crucially, this exposes the identity details of who actually joined the call, rather than who was merely invited on the calendar.

"Who attended the meeting associated with conference record 'MTR-893-X'? Extract their email addresses."

list_all_meet_conference_record_transcripts

Queries the system for any generated transcripts attached to a specific conference record. Because transcripts are generated asynchronously, this tool returns the transcript document references that the agent must use to read the actual text.

"Check if a transcript has been generated yet for conference record 'MTR-893-X'. If so, give me the transcript ID."

list_all_meet_conference_record_transcript_entries

This is the core tool for data extraction. It fetches the actual spoken text from a meeting transcript. It requires both the conference_record_id and the conference_record__transcript_id.

"Read the transcript entries for transcript 'TR-555' from meeting 'MTR-893-X'. Summarize the key decisions made during the call."

list_all_admin_users

Queries the Google Workspace directory. This is incredibly useful for mapping participant display names or external emails to internal employee records for cross-referencing.

"Get the Google Workspace directory ID and primary email for the user named 'Sarah Jenkins' so we can verify her meeting attendance."

For the complete inventory of available tools, required parameters, and JSON schema definitions, visit the Google Meet integration page.

Workflows in Action

By chaining these tools together, Claude can execute complex, multi-step workflows entirely autonomously. Here are two real-world scenarios.

Scenario 1: Automated Action Item Extraction

An engineering manager wants a summary of commitments made during yesterday's architectural review, without having to manually read a 60-page transcript.

"Find the conference record for my architectural review meeting yesterday. Fetch the transcript entries and generate a bulleted list of technical action items, assigning them to the person who spoke the commitment."

Step-by-step execution:

1. list_all_meet_conference_records: Claude queries the recent records to find the ID for the architectural review.
2. list_all_meet_conference_record_transcripts: Using the record ID, Claude checks for available transcript documents.
3. list_all_meet_conference_record_transcript_entries: Claude calls this tool (potentially multiple times if paginated) to ingest the raw conversation text.
4. Analysis: The model processes the text internally, identifies statements like "I will update the schema by Tuesday," correlates them with the speaker labels, and outputs the formatted action items to the user.

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant API as Google Meet API

    User->>Claude: "Extract action items from yesterday's review."
    Claude->>Truto: Call tool `list_all_meet_conference_records`
    Truto->>API: GET /v2/conferenceRecords
    API-->>Truto: Return records
    Truto-->>Claude: JSON result
    Claude->>Truto: Call tool `list_all_meet_conference_record_transcripts`
    Truto->>API: GET /v2/conferenceRecords/{id}/transcripts
    API-->>Truto: Return transcript IDs
    Truto-->>Claude: JSON result
    Claude->>Truto: Call tool `list_all_meet_conference_record_transcript_entries`
    Truto->>API: GET /v2/conferenceRecords/{id}/transcripts/{id}/entries
    API-->>Truto: Return spoken text blocks
    Truto-->>Claude: JSON result
    Claude-->>User: Formatted action item list

Scenario 2: Compliance Auditing for External Participants

A security admin needs to verify if any non-company personnel were present during a sensitive internal strategy meeting.

"Check the participant list for the Q3 Strategy meeting (record ID 'MTR-991-A'). Flag any participants whose email domains do not match '@acmecorp.com'."

Step-by-step execution:

1. list_all_meet_conference_record_participants: Claude requests the participant list for the specified meeting ID.
2. Data Processing: Claude receives the array of participant objects, parsing the identity and email address fields.
3. Analysis: The agent evaluates the domains against the specified string (@acmecorp.com).
4. Reporting: Claude returns an alert to the admin, highlighting two participant objects that joined via personal Gmail accounts.

Moving Forward

Building an AI agent that can reliably query, paginate, and parse Google Meet transcripts requires more than just calling an LLM endpoint. The bottleneck is the integration architecture. If you build custom MCP servers, your engineering team owns the OAuth state, the token refreshes, the schema mapping, and the inevitable maintenance when Google deprecates a V1 resource.

By leveraging a platform like Truto, you abstract the infrastructure away. You generate a secure, scoped MCP URL, hand it to Claude, and let the model navigate the API autonomously. This shifts your engineering focus from maintaining REST boilerplate to actually refining the intelligence of your AI workflows.