Google Workspace

A chart over a data range: the first column is the domain (x axis, pie labels), the other columns (or series_columns) the series.

A new comment thread on a Drive file, as the account. `quoted` shows the text it is about beside it. Google Docs shows a comment made through the API on the file, not anchored to text (Google's limit); `anchor` is for file types whose viewer reads one. Everyone with access to the file sees it.

Events across EVERY account at once, in time order, for a window: today and the next days by default. Also returns `conflicts` (busy events that overlap, including across accounts, e.g. a work meeting over a dentist appointment), `probableDuplicates` (one appointment booked into both accounts as two events) and `pendingInvites` (invitations not yet answered). Recurring events are expanded into their instances; an event seen through both accounts is listed once, with `alsoOn`. Declined events are left out unless asked for. Each event carries the account, calendarId and eventId that get_event, update_event, delete_event and respond_to_invite need. include_tasks adds `tasksDue`: the Google Tasks not yet done that fall due on the window's days (a task has a due date, never a time).

Rows after the last one holding data, keyed by the header, formatted like the row above. One atomic batch.

Markdown added after the document's last paragraph, in one batch.

Rows after the table Sheets finds at an A1 range (values.append), as new rows (INSERT_ROWS) or over empty ones (OVERWRITE). Returns where they went. Not retried after a lost answer, since a retry would add them twice. append_rows is the variant keyed by a header row.

Any Google Docs API batchUpdate: text, styles, bullets, tables (insert, merge, row and column, cell style), images by URL, headers, footers, footnotes, page and section setup, named ranges, tabs, replace all text, and the rest; local images through `images`. One atomic batch, checked against the API's schema before anything is sent (a wrong field is refused with the nearest right name). Requests apply in order, each to the document as the ones before left it: work from the end of the document backwards so earlier indices stay valid. A batch that names an index needs expected_revision (refused if the document changed) or target_revision (Docs carries the positions over later edits), from get_document or find_in_document. In a tab other than the first, put tabId in each location and range. Returns the new revisionId and the replies that carry ids or counts, by request position.

Any Google Slides API batchUpdate: slides (create, duplicate, reorder, delete, background), shapes, text boxes, images (by URL, or local files through `images`), videos, lines, tables (rows, columns, merges, cell and border styles), Sheets charts, text and its styles, bullets, replace all text or shapes with images, transforms, z-order, alt text and the rest. One atomic batch, checked against the API's schema before anything is sent. Ids you choose for new objects (5 to 50 characters, starting with a letter or _) can be referred to by later requests in the same batch. expected_revision (from get_presentation) refuses the batch if the deck changed. Returns the new revisionId and the replies that carry ids, by request position.

Any Google Sheets API batchUpdate: sheets (add, duplicate, delete, properties), rows and columns (insert, delete, move, resize, group, hide), cells (values with formats, repeat a format, borders, merges, copy/cut/paste, sort, find and replace, data validation, autofill), conditional formatting, filters and filter views, protected, named and banded ranges, charts, slicers, tables, pivots (as cell data) and developer metadata. One atomic batch, checked against the API's schema before anything is sent. Where a request takes a GridRange, GridCoordinate or DimensionRange, A1 naming the sheet works too ("Sheet1!A1:C10", "Sheet1!B3", "Sheet1!3:5" for rows, "Sheet1!B:D" for columns); a sheet added in the same batch is named by the sheetId set in its addSheet. Colours are {red, green, blue} from 0 to 1. Returns the replies that carry ids or counts, by request position.

Start granting one product access to one account: gmail (its own gmail.modify grant), calendar, editors (Docs, Sheets, Slides), drive (Drive's one grant), tasks (Google Tasks), contacts (contacts, saved addresses and a Workspace directory, read only) or meet (Meet records and transcripts, read only). Returns the URL to open in a browser, where the user approves as the account named. The redirect then fails to load; pass the URL it tried to complete_consent within 15 minutes. No token ever leaves the server.

Empty the values of several A1 ranges (or the cells data_filters choose), keeping their formatting, validation and notes. Returns the ranges cleared.

Finish a consent from the URL the approval redirected to (http://localhost:...?state=...&code=...). The grant is checked (the right account, every scope ticked, a refresh token) and saved where the product reads it, and the product uses it from the next call. Returns what was granted, never a token.

Mark a task done, or open again with completed: false. A task already in that state is left as it is.

Copy one file to a folder, retaining native Google formats and formulas. Does not copy folders, comments or version history. Refuses existing names; inspect the destination after an uncertain response before retrying. Original is unchanged.

One sheet, with its formats, charts and validation, copied into another spreadsheet (or the same one when destination is empty). It arrives last, titled "Copy of <title>"; returns its sheetId and title.

Copy a template deck through Drive, then add one slide per outline entry from the named layout, filling its title/subtitle/body placeholders and speaker notes, and delete the template's own slides unless kept. The outline is checked against the template before anything is copied.

A new Google Doc from markdown, in a Drive folder or My Drive's root. Returns its id and link.

Save a NEW message as a draft. The default path for anything addressed to someone: nothing leaves the mailbox, and the result carries the draft's webUrl for the user to review and send. For an answer to an existing message use reply (it drafts by default and threads properly), not this.

Add an event to one account's calendar. Needs title and start; a timed event with no end lasts an hour. Times without an offset are in UTC. Guests are NOT emailed unless send_updates says so. meet: true gives it a new Google Meet link. event_type makes focus time or an out of office block instead of an appointment (title optional for those).

Create a Gmail filter for mail that arrives from now on. Actions are labels, by name or id: add a label to file it; remove INBOX to skip the inbox, UNREAD to mark it read; add STARRED or IMPORTANT. Adding TRASH or SPAM needs discard: true, since such mail is never seen. No forwarding. It does not touch mail already there: the result's filter.query is the search to give modify_labels_matching for that. Gmail has no filter update; to change one, create the new one and delete the old. Needs the gmail.settings.basic scope on the account's grant, and says so if it is missing.

Create a folder and every missing folder above it, in one call. Returns which levels it had to create, so a typo shows up as a folder you did not expect to be new.

Create a user label. Nest it under another with a slash in the name, e.g. 'Clients/Acme'.

A new, blank Google Slides deck in a Drive folder or My Drive's root, to build with batch_update_presentation. Returns its id, link, revisionId and the object id of the title slide Slides gives every new deck.

A new Google Sheet, optionally with named sheets and bold, frozen header rows, in a Drive folder or My Drive's root.

Add a task to one account's list. Needs a title; notes and a due date are optional. parent makes it a subtask of another task in the same list; previous places it after that sibling (first otherwise).

A new Google Tasks list in one account; returns its taskListId.

Delete a comment thread with its replies, or one reply with reply_id. Drive lets an account delete only what it wrote (owners excepted).

Delete a draft permanently (drafts do not go to Trash). The draft's message is gone with it.

Delete an event (an instance id from agenda deletes that one occurrence; a series id, every occurrence, is refused unless scope is "series"). On an event someone else organised this removes it from this calendar only; to say no, use respond_to_invite with declined.

Delete a Gmail filter by id (list_filters). Mail it already filed keeps its labels.

Delete a user label, given by id or name. It is removed from every message that carries it; the messages themselves are untouched. System labels are refused.

Everything Drive reports about a single file or folder, by id or path.

Save a file from Drive into /home/sandbox/.local/state/mcps/google/drive/downloads, which you can read, and prove it: the bytes are checked against Drive's own checksum before anything is written, so a damaged download is never saved. For a file no local copy has yet, or one known only by its id. A Google Doc, Sheet, Slides deck or Drawing has no bytes and is exported instead (a Doc as pdf, a Sheet as xlsx, Slides as pptx, a Drawing as png, unless format says otherwise). An earlier download of the same name in that folder is replaced. Returns the file with the saved path, size, sha256, md5 and verifiedBy (exportedAs for a Google file).

One revision of a file into the downloads folder: a file with bytes as it was, checked against the revision's MD5; a Google file exported (a Doc as PDF unless `format` says otherwise). Returns the path, size and sha256. To roll back, upload it as a new version.

Every file created, edited, moved, trashed or removed since the cursor, and a new cursor to use next time. Only the delta comes back, so this costs the same whether the Drive holds 20 files or 20,000. Call it again while exhausted is false to drain the backlog.

New text for a comment, or for one of its replies with reply_id. Drive lets an account edit only what it wrote.

Replace everything under one heading (its subsections included) with markdown, keeping the heading. Read the section with read_document first and pass its revisionId: the edit is one batch, pinned to that revision. Headings in the new body must be deeper than the section's own. Refused when the section holds images, footnotes or other things read_document does not show (drop_hidden: true deletes them), and for an empty body (clear: true empties the section). Returns the document's title and the section's size before and after, in characters of markdown.

What a Google Docs, Sheets or Slides batchUpdate request takes, from the API's own schema (the revision batch_update_document, batch_update_spreadsheet and batch_update_presentation check against): each field's type, allowed values and meaning, with the types it refers to expanded `depth` levels down (`more` lists the rest by name). Name a request kind (updateTextStyle, repeatCell, createShape) or any type (TextStyle, CellFormat, PageElementProperties); with no name, every request kind and its one-line summary. Kinds marked Developer Preview need the Cloud project in Google's preview program.

Replace every {{tag}} with its value (exact case) across the deck, or only the slides named. Reports how many of each were found.

Search the whole Drive without listing it. Combine any of name_contains, full_text, mime_type, parent_id and modified_after; they are ANDed. This is the tool to reach for instead of walking folders, or a local copy of the Drive, which costs a full tree scan for the same answer.

Every place a text appears in one tab of a Google Doc (body, headers, footers and footnotes unless segments is body), as ranges [startIndex, endIndex) to use in batch_update_document (with tabId and, outside the body, segmentId), each with its paragraph's range and named style. Returns the revisionId the ranges are right for. With regex, text is a JavaScript regular expression (run under a time limit); a match never crosses a paragraph.

Find a person's email address by name, across every account at once: each account's contacts, the addresses Gmail saved from mail it sent or received ('other'), and a Workspace domain's directory. The query matches the start of a name, an address, a phone number or an organisation. One entry per person, merged by address, with every account and source it was found in; a source an account cannot read is listed under `unavailable` with the reason. Use it before addressing a draft or an invitation to someone named.

Candidate slots of `duration_minutes` across EVERY account (and optional `attendees`), inside working hours (default Mon-Fri 09:00-18:00 UTC), after a minimum notice, clear of existing events plus buffers, on a step grid, ranked earliest first or with mornings/afternoons first. Returns `slots` (overlapping candidates, e.g. 09:00 and 09:30 for an hour) and `ranges` (the free stretches they come from). Tentative events block time unless `tentative_is_free`. If some busy time could not be read, `complete` is false and `unknown` says what.

Number format, bold/italic, colours, alignment, wrapping, borders and frozen rows/columns for a range. Only what is given changes.

Forward a message WITH its attachments, under Gmail's 'Forwarded message' block, with an optional note above it (body_text / body_html). Creates a DRAFT unless send is true. Extra attachments can be added.

When the user is busy across EVERY account in a window, per calendar, plus one merged, de-duplicated `busy` timeline that also covers any `attendees`. Busy means: not cancelled, not "show as available", not declined; tentative events and "maybe" answers count as busy and are flagged `tentative`; an all-day event left as busy blocks its whole day. Anything that could not be read is listed under `unknown` and `complete` is false.

Download one attachment to disk by message_id + attachment_id (both come from get_thread). This is the capability Google's own Gmail MCP server does not have: it reports an attachment's name and id and gives you no way to fetch the bytes. Returns the path, size and sha256; a download whose size differs from the one Gmail reports for the part is refused and nothing is saved. A different file already saved under the name is kept, and this one is saved as "name (2).ext".

A Google Doc's structure with the indices batch_update_document needs: every tab, and for one tab its body as elements (paragraphs with named style, heading id, bullet, styled runs and objects such as images or footnote marks; tables with each cell's range and content; section breaks; tables of contents), each with range [startIndex, endIndex). A paragraph's `text` holds one U+FFFC per non-text index, so offset k of text is index range[0]+k; its newline is range[1]-1. Styles are shown short ("11pt", "#1a73e8"); in requests write {magnitude: 11, unit: "PT"} and {color: {rgbColor: {red, green, blue}}} (0 to 1). `parts` adds headers, footers, footnotes, lists, named ranges, objects (image sizes and sources) and styles (page setup, named styles); `notShown` says what exists beyond them. A long body is cut at an element (`nextIndex`: read on with start_index). format raw returns the API's JSON, narrowed by `fields`. Returns revisionId for expected_revision. For prose, read_document's markdown is cheaper.

One draft: its message (headers, Bcc included, bodies and attachments) and its webUrl.

One event in full: description, guest list with each answer, reminders, meeting link, recurrence.

Fetch a single message by id. See get_thread for the detail levels and the account rule.

Fetch several messages of one mailbox in one call, up to 25 ids, in the order given (a repeated id once). Use it after list_history or a search when you need the bodies of messages from different threads. A message that cannot be read comes back as {id, partial: true, reason} in its place and the others still arrive. See get_thread for the detail levels and the account rule; 'metadata' keeps a long list cheap.

A Google Slides deck's structure with the object ids batch_update_presentation needs: per slide its layout, every element (shapes with type, placeholder and full text, images, tables cell by cell, lines, videos, Sheets charts, groups) with size and transform, and the speaker notes' shape id; plus layouts, masters and the page size. A shape's text is exact, so offset k is index k for insertText and text ranges. Sizes show as "3000000 EMU"; requests take {magnitude, unit}. A long deck is cut at a slide (`nextSlide`: read on with from_slide). format raw returns the API's JSON, narrowed by `fields`. Returns revisionId.

A spreadsheet's structure with the ids batch_update_spreadsheet needs: per sheet its sheetId, size, frozen rows and columns, merges, conditional format rules (with their index), basic filter, filter views, protected and banded ranges, charts, slicers, tables and row/column groups, plus named ranges; ranges as A1. No cell data (get_values, read_rows). format raw returns the API's JSON for `ranges`, with grid data if asked, narrowed by `fields`: the way to read cell formats, notes, validation and pivots.

Fetch one thread with all its messages, their attachment metadata and their bodies. Thread ids are per-mailbox: pass the account that search_threads reported alongside the id.

A PNG thumbnail URL per slide, rendered by Google. The URLs expire after about half an hour.

A Meet transcript as text, one line per thing said: "[0:12:05] Ana Popescu: ...", the time counted from when the transcript began. Long ones come in parts of about max_chars; pass nextPageToken back to read on. The transcript is the name list_meetings gives (conferenceRecords/.../transcripts/...).

Values of several A1 ranges in one read, as Sheets renders them (FORMATTED_VALUE), as numbers (UNFORMATTED_VALUE: a double, so read_rows is the tool for money) or as formulas (FORMULA), chosen by A1 ranges or by data_filters. A large answer is cut at a row (`totalRows` says how many there were).

Every attachment matching a Gmail query, downloaded to a folder in ONE call, with a manifest. Use it for a month of invoices ('has:attachment after:2026/08/01 before:2026/09/01') instead of walking threads and calling get_attachment per file. Do NOT use Gmail's own 'download all attachments' zip as an alternative: it is keyed by thread id and silently omits parts keyed by message id. Returns counts (threadsMatched, attachmentsFound, savedCount) so the harvest can be reconciled against Gmail's own has:attachment count, each saved file with its size and sha256, plus a per-file failure list. Files are named <message id>-<filename>; two of one name both survive. A client that asks for progress hears each attachment saved, out of how many; cancelling stops the harvest, which then ends as cancelled.

Check that every grant is alive, per product and per account. Under `gmail`, per grant: the mailbox each credential resolves to, the scope Google actually GRANTED (not the one credentials.json declares), whether it can write, and the OAuth client the live token belongs to; an account may hold its own gmail.modify grant and a gmail.readonly one, and `activeGrant` is the one the tools use. Under `calendar`: that the grant refreshes, which account it resolves to (the consent screen offers every account signed in), and whether it carries the scopes the tools need. Under `drive`: which account the grant acts as and the storage used. Under `editors` (Docs, Sheets, Slides), per account: the address, the granted scopes, and whether each of the three APIs is enabled in the grant's Cloud project. Under `tasks`, `contacts` and `meet`, per account with a grant: the address, the granted scopes, and whether the API answers (`disabled` when its Cloud project has not enabled it); contacts also says which sources it reads. Under `config`: where the state directory, the OAuth client, the mailboxes and each account's address come from (a variable, or what setup or a consent saved; a variable that is set wins). Checks EVERY account by default. Run this before concluding the server is broken, and before retrying a write that refused.

Add or replace hyperlinks on existing plain text cells in one atomic batch. Keeps their values, validation and all other formatting. Row and column are 1-based. Every cell must still contain expected_text; formulas, rich text and chips are refused before any write.

The Google accounts this server reaches, per product. Start here: every other tool takes one of these labels. Under `gmail`: the mailboxes, which one a tool uses when no account is given, and which grant each runs on: `modify` (its own; the write tools work) or `readonly` (a read-only grant; the write tools refuse). Under `calendar`: the accounts whose calendars it reaches, the address each grant must resolve to, and the time zone. Under `drive`: which grant Drive runs on (its own once begin_consent made one, else an rclone remote's when one is configured). Under `editors`: the accounts Docs, Sheets and Slides can act as (one may run on the Drive grant; any other needs a grant made with begin_consent). Under `tasks`, `contacts` and `meet`: the accounts with a grant for Google Tasks, for contacts and the directory, and for Meet's records. Says nothing about whether a grant is alive; that is health, which costs a round trip to Google.

Takes no parameters.

Every calendar each account can see (its own, shared ones, subscriptions, holidays), with its id, the account's access to it, and whether agenda reads it by default.

The comment threads on a Doc, Sheet, deck or any Drive file, each with its author, time, text, the text it quotes, whether it is resolved, and its replies (with any resolve or reopen action). Counts the open and resolved threads.

The account's drafts, newest first, with recipients, subject, snippet and each draft's webUrl.

The mailbox's Gmail filters: criteria, the labels each adds and removes (by name), and `query`, the search its criteria amount to, for applying it to mail already there with modify_labels_matching.

The direct children of one folder. Give file_id or path; empty path means the root of My Drive. Google Docs come back with isNative true and bytes null, because a Doc has no stored bytes.

Messages added since a historyId: incremental sync instead of re-searching the same window. Take the anchor from health's historyId, store it, pass it back next run. Anchors are per-mailbox, so keep one per account. Gmail expires old anchors: a 404 here means the anchor is too old and a full search_threads is needed to re-baseline.

List Gmail labels (system and user-defined) for one account.

A deck's (or template's) layouts, by name, and the placeholders each has (TITLE, SUBTITLE, BODY, ...).

The Google Meet meetings one account took part in, each with its transcripts, smart notes (Gemini's notes) and recordings, as Meet records them: for a calendar event (event_id from agenda: its Meet call, and for one occurrence the sitting that started within an hour of it), for a Meet link or code (meeting), or else for the last days (at most 30: Meet keeps records 30 days). A transcript or notes is a Google Doc: its document id opens with read_document; get_transcript reads a transcript as lines with who said what. Reading an event needs the account's calendar grant too.

Every permission on a Drive file: each person, group, domain or link with its role, expiry and id, whether it comes from a shared drive, and the link sharing in one line. Read it before share_file, update_permission or remove_permission.

A Drive file's revisions, oldest first: id, time, who made it, size and checksum for files with bytes, whether it is kept forever or published, and for a Doc, Sheet or deck the formats an old revision can be saved as with download_revision.

A spreadsheet's title, locale, time zone and sheets (id, name, size, frozen rows).

Every Google Tasks list of each account (every account by default), with the taskListId the other task tools take; the default list is marked.

Tasks across every account by default, from every list unless task_list names one, in each list's own order. Open tasks only unless include_completed. due_from and due_to keep the tasks due between those dates (inclusive), which leaves out tasks with no due date. Each task carries account, taskListId and taskId for the write tools, parent when it is a subtask, and its link in Google Tasks. agenda with include_tasks shows the tasks due beside the events.

Report threads or messages as spam: into SPAM and out of the inbox, as Gmail's own button does.

Add and remove labels on threads or messages. In Gmail these ARE the everyday actions: archive = remove INBOX; mark read = remove UNREAD (unread = add it); star = add STARRED; important = IMPORTANT. Labels may be given by id or by name, case-insensitively. For threads, ids that failed are listed under `failed` beside the ones changed.

Add and remove labels on EVERY thread a Gmail search matches, as Gmail's "select all conversations that match this search" does: file a sender under a label and archive it (add the label, remove INBOX), mark old mail read (remove UNREAD). A dry run by default: it returns how many threads match and a sample, and changes nothing. With dry_run false it refuses when the search matches more than `limit`, and otherwise changes every match, listing any thread that failed. To be able to find and reverse a large change later, also add a marker label created for it (e.g. 'cleanup/2026-10').

Move one or many files into a folder, optionally renaming a single one. Sources are paths, or "id:<fileId>" to name one directly. Works the same for a Google Doc as for a PDF, which is the reason to use this instead of moving files in a synced local copy: moving a Doc's placeholder there deletes the Doc and uploads a small shortcut file in its place. Call with dry_run first; the plan names every collision.

Move a task: under parent (a subtask; top level when omitted), after previous (first among its siblings when omitted), and into another list of the same account with to_list. A repeating task cannot change lists.

The reverse of resolve_path: where a file sits, as a path, by walking its parents to the root.

Every slide's layout, title, other text (tables as rows) and speaker notes, in order.

Export a Google Doc, Sheet or Slide deck as text and return it. Sheets come back as CSV. A Doc has no bytes to download, and this fetches its words in one request. Binary files are refused on purpose; download_file saves their bytes.

A Google Doc as markdown (headings, lists, tables, bold/italic/links), with an index of its sections: each heading's stable id and path ("Plan > Risks"). Pass `section` (an id, a path or a unique title) to read one section. Returns revisionId for a later edit's expected_revision. Reads the first tab unless `tab` names another; images, footnotes and the like are left out, and `notShown` counts them.

Rows as objects keyed by the header row. Values are typed: numbers stay numbers, dates are ISO strings (sheet-local time), and a currency cell is {value, amount, formatted} with `amount` its exact decimal string. Each row has `_row`, its row number. Empty rows are skipped.

Sparse cells with entered formulas, shown values, hyperlinks, rich-text links, smart chips and notes. Row and column numbers are 1-based. offset counts physical rows; follow nextOffset until null. Use this before changing a link or formula, rather than inferring it from read_rows display text.

Remove one permission from a file: that person, group, domain or link loses access. Inherited shared-drive access cannot be removed here. It changes who can open the file: do it only on the user's explicit go for this file and these people.

Change a file's name in place. Names cannot contain a slash; Drive has no path, only parents.

Answer a message, threaded properly for every party: the original's threadId, In-Reply-To and References, a 'Re:' subject, and the recipients Gmail's own Reply picks (Reply-To when the original has one, else From; a reply to a message you SENT goes to its recipients). Goes out from the alias the original reached. Creates a DRAFT unless send is true. `to` replaces the computed recipients; `cc` and `bcc` add to them.

A reply on a comment thread, and/or its resolve or reopen (`action`), as the account; what the comment box's Reply and Resolve buttons do.

Walk a path and return the id it names. A path is a QUERY on Drive, not an address: two objects may hold the same name in one folder, and this reports that as an error listing both ids rather than picking one. Use it before any tool that writes. A Drive name may itself contain a slash (Google Meet writes folders like "Weekly sync - 2030/01/15"); those are reachable only by id, which find_files returns.

Answer an invitation: accepted, declined or tentative. Changes only your own answer. The organiser sees it on the event either way; send_updates=all also emails them.

Developer metadata: key/value tags a program attaches to the spreadsheet, a sheet, or rows and columns (createDeveloperMetadata in batch_update_spreadsheet), which then name those cells in data_filters. One tag by metadata_id, or every tag data_filters match (e.g. [{"developerMetadataLookup": {"metadataKey": "invoice-table"}}]), each with where it is attached as A1.

Search threads with Gmail query syntax, e.g. 'from:billing.example.com after:2026/01/01 has:attachment', 'subject:invoice newer_than:30d', 'label:INBOX is:unread'. Searches EVERY registered mailbox by default and tags each result with the account it came from, so a question that does not know which mailbox holds the answer needs one call. Returns summaries; use get_thread for bodies.

Send an existing draft as it stands. SENDING IS OUTWARD-FACING AND CANNOT BE UNDONE: only send when the user has explicitly approved THIS message (its recipients and its text) in the current conversation. Otherwise create a draft and give the user its webUrl. Returns the sent message's webUrl.

Send a NEW message immediately. SENDING IS OUTWARD-FACING AND CANNOT BE UNDONE: only send when the user has explicitly approved THIS message (its recipients and its text) in the current conversation. Otherwise create a draft and give the user its webUrl. Prefer create_draft. To answer an existing message use reply, which threads it. Returns the sent message's webUrl.

Who the threads matching a query come from: per sending domain, busiest first, the thread and unread counts, the newest and oldest date, and its busiest addresses. The starting point for sorting a mailbox into labels and filters. A thread's sender is the author of its latest message you did not send. One mailbox per call. A few hundred threads take seconds; past that Gmail's quota allows about 25 threads a second, so a 3000-thread inbox takes about two minutes.

Give a person or group (email_address), a domain, or anyone with the link access to a Drive file, as reader, commenter, writer (organizer roles on shared drives), with an optional expiry. Drive's email goes out only with notify: true, with `message` in it. Making someone the owner needs transfer_ownership: true. It changes who can open the file: do it only on the user's explicit go for this file and these people.

A token meaning "from now on". Keep it, and hand it to drive_changes later. This is the cheap half of keeping anything in step with Drive: one call, no listing.

Takes no parameters.

Move threads or messages to Trash, where Gmail keeps them 30 days. There is no permanent delete here. Returns the ids trashed, and any that failed under `failed`.

Send a file to Drive's trash, where it stays recoverable for 30 days. There is deliberately no permanent-delete tool here: the one operation that cannot be undone is the one this server does not expose.

Take threads or messages out of SPAM and back into the inbox.

Bring threads or messages back out of Trash. Returns the ids restored, and any that failed under `failed`.

Take a file back out of the trash. Find it by id; a trashed file no longer answers to its path.

Change an existing draft. Only the fields you pass change; everything else, including a reply draft's threading, is kept. Passing either body replaces both bodies. Attachments are kept unless you pass a list, and an empty list removes them.

Change an event. Only the fields given change; a new start with no end keeps the event's length. On a recurring event, the eventId decides the reach: an instance id from agenda changes that one occurrence, and a series id (every occurrence) is refused unless scope is "series". attendees replaces the guest list, and the result says who that added and removed. Guests are NOT emailed unless send_updates says so. meet: true adds a Meet link to an event without one. An event's type cannot change; a focus time or out of office event takes new auto_decline, decline_message and chat_status.

Rename or restyle a user label, given by id or name. System labels (INBOX, SENT, ...) are refused.

A permission's role or expiry (or its expiry removed). Making someone the owner needs transfer_ownership: true. It changes who can open the file: do it only on the user's explicit go for this file and these people.

keep_forever stops Drive pruning a revision of a file with bytes. published puts a Doc, Sheet or deck revision on the web for anyone at its publishedLink (publish_auto follows later revisions, published_outside_domain lets people outside the domain read it): only on the user's explicit go.

Change a task's title, notes or due date. Only the fields given change, and only when they differ: an empty notes or due clears it. To mark it done use complete_task; to move it, move_task.

Values or formulas into several A1 ranges in one call (values.batchUpdate). Returns the cells updated per range (and what they now show, with include_values). write_range is the one-range variant that returns what the cells held before.

Put a file on Drive byte for byte and prove it: after the upload, Drive's own checksum of what it stored (or the bytes read back, when Drive reports none) is compared with the source's. A difference fails the call and is taken back: a replacement's damaged revision is deleted, a new file is trashed. The file goes as path (a file in your workspace folders (the roots this client shares with the server; without them /workspace/mcp-validate); a bare name is taken from the first) or as content_base64 with its sha256. Never type or paste a file's base64 yourself: a retyped file can arrive changed. Give the path of a file in your workspace folders (the roots this client shares; without them /workspace/mcp-validate), or have a script that read the file send content_base64 with its sha256. The folder is folder_id, else folder_path, else the root. A name already in the folder is refused unless if_exists says what to do. A file given by path keeps its modification time on Drive. Returns the stored file with its link, size, sha256, md5 and verifiedBy. With convert, an Office file (.docx, .doc, .xlsx, .xls, .csv, .pptx, .ppt) becomes a Google Doc, Sheet or deck instead, named without its extension; a converted file keeps no bytes to compare, so the check is that Drive made the Google type, and the result gives the source's size and sha256 under `source`.

Update the rows whose `key` column matches (only the columns given change), append the rest. One atomic batch. A key on two sheet rows is refused.

Values or formulas into an A1 range that names its sheet ("Invoices!A2:C4"), parsed as if typed (USER_ENTERED): "=SUM(B2:B9)" is a formula, "28/09/2026" a date in the sheet's locale. Returns `before`, what those cells held (formulas as formulas), so the write can be undone by writing it back.