approval_decide
ChatGPTReject a send that is waiting for human approval, so it is never delivered. decision accepts only "reject". Approving is deliberately not available over MCP — it requires a signed-in browser session with an owner or admin role, at the review_url of the approval.
approval_review
ChatGPTFetch the full contents of a send that is waiting for human approval, including its body, so it can be shown in the review card. Read-only. Approving is not possible from here: it requires the signed-in review page linked as review_url.
approval_schedule
ChatGPTSet the delivery time of a send that is waiting for human approval. Nothing is queued until it is approved; this only decides when an approved message goes out. send_at must be in the future.
approval_update
ChatGPTChange the subject or body of a send that is waiting for human approval. The message still has to be approved afterwards, and the reviewer sees the edited version. Subject can only be set on operations that carry one (email_send, schedule_create).
automation_delete
ChatGPTDelete an automation. Its run history is KEPT: that history is the record of what was done to the mailbox, and it is what a user goes looking for afterwards.
automation_disable
ChatGPTTurn an automation off. A run already in progress finishes its current batch (stopping mid-batch would leave a partial application with no record of where it stopped); nothing further is scheduled.
automation_get
ChatGPTRead one automation in full, including its filter, action and failure state.
automation_list
ChatGPTList every automation in the workspace, with its schedule, action and health.
automation_preview
ChatGPTDRY RUN. Runs a filter against the inbox and reports what it matches right now. Applies nothing, sends nothing, and does not claim any message in the deduplication ledger. It takes an automation_id (a stored rule) or a filter (one not yet saved) and shows a rule's effect before it is enabled. With an automation_id the inbox comes from the stored rule, so no inbox_id is needed; with a filter the inbox is required.
automation_runs
ChatGPTList an automation's recent runs with their counters (matched, processed, succeeded, failed, skipped). A high skipped count against a low processed count means an overlapping run was correctly deduplicated.
bulk_cancel
ChatGPTDecline a previewed bulk delete or move, so it can never run. Takes only the plan_id. Nothing in the mailbox changes. A preview would also expire on its own after 15 minutes; cancelling records the decision instead of leaving it implicit.
bulk_execute
ChatGPTRun a bulk delete or move that was previewed as a plan. Takes only the plan_id: which messages are affected was decided and frozen when the preview was created, and cannot be changed here. A plan runs at most once and expires 15 minutes after it is created.
contact_search
ChatGPTFind people by name or email fragment. There is no stored contact list: each call runs a bounded, header-only scan of a RECENT window of matching mail, so message_count counts matches inside that window, not an all-time total. Returns display name, address, count and last-contacted time, most recent first. Without inbox_id every accessible inbox is scanned, which answers cross-inbox questions ('who do I email most about X?'). Results are paged like email_search: has_more: true means another page at next_offset with otherwise identical arguments; only has_more: false means every contact the scan found is in hand. total counts the correspondents that scan found: when total_is_estimate (or scan_truncated) is true the window was full, so more people may exist beyond it that paging cannot reach; a narrower query does. Display names come from other people's mail headers: the result is marked untrusted_content: true.
draft_create
ChatGPTSave a new email draft in the inbox's Drafts folder without sending it. Use this when the user wants to review or edit a message before it goes out; email_send sends now. A saved draft is where the user can see and edit the email. Returns a draft_id that can be used with draft_update or draft_send. Only body is required; subject and to/cc/bcc are optional (drafts may be incomplete). attachments puts files on the draft: inline base64 in attachments[].data, or a file already in this inbox by source_message_id. Where the draft editor card is on, hosts that render MCP Apps cards show the draft to the user in an editable card, where the user can change it; draft_read returns a draft's current text. The user can also save or send it there with no notice to this tool, so a draft's current subject, recipients and sent state are what draft_read reports. The result echoes the stored draft and is marked untrusted_content: on Gmail and Outlook a draft can be edited outside this server between calls.
draft_delete
ChatGPTPermanently delete a saved draft without sending it. Irreversible: the draft is removed from the Drafts folder. draft_id is the most recent one (from draft_create, the latest draft_update, or draft_list): on IMAP-backed inboxes the id changes on every update, and a stale id fails with a not-found error.
draft_editor_hide
ChatGPTHide the in-chat draft editor card, or show it again, when the user asks for that, either for one inbox or for the whole workspace. This is a display preference only: drafts, sending and every other tool are completely unaffected, and the same draft results keep coming back as plain text. Pass hidden:false to turn it back on, which works at either scope even while the card is hidden. Hiding or showing it for the WHOLE workspace changes it for every member, so that scope needs a workspace owner or admin; one inbox needs no extra role.
draft_editor_save
ChatGPTSave the fields a person edited in the draft editor. Every field is optional and an omitted one keeps its stored value. No signature is applied, unlike draft_update when it is given a body: the text being saved is the text the person was shown, which already carries one if the inbox has one. Nothing is sent. On IMAP the save returns a NEW draft_id and the old one stops resolving. On IMAP and Gmail the save rebuilds the message from its text, so a draft with attachments, inline images other than its own signature images, or other extra parts is refused and left unchanged. A save against an older id of the draft, or against a revision other than base_revision, is refused as draft_changed and nothing is written.
draft_list
ChatGPTReturn draft messages saved in the inbox's Drafts folder. Each result includes the draft_id, subject, recipients, and created timestamp, and no body: draft_read returns one draft's text. draft_id is what draft_read, draft_update, draft_send and draft_delete take. The user can edit, save and send a draft in the draft editor card with no notice to this tool, so its current subject, recipients and sent state are what draft_read reports. A reply draft's subject and recipients are derived from the message it answers, so the result is marked untrusted_content: true.
draft_read
ChatGPTGet the current text of one unsent draft, for example before revising a draft the user edited in the draft editor card. Returns recipients, subject, body_text and attachment names. Read-only: nothing is written and nothing is sent. Needs the 'read:email' scope as well as 'manage:drafts'. The user can edit, save and send a draft in the draft editor card with no notice to this tool, so this read is its current subject, recipients and sent state: a sent draft answers that it was already sent. Where the card is on, the host shows a one-line summary for this read rather than a second editor. A draft's subject, recipients and body may come from a message somebody else sent, so the result carries untrusted_content: true.
draft_reply
ChatGPTCreate an unsent reply draft for an existing email. The recipient (Reply-To if the original has one, otherwise From), subject, threading headers, quote, and reply signature are derived from the original message. reply_all: true also addresses every original To and Cc recipient. Requires both manage:drafts and read:email; it never sends mail. A saved reply draft is where the user can see and edit the reply. attachments puts files on the reply, in the same two shapes as draft_create. The subject it returns is 'Re: ' plus the original sender's own subject line, so the result is marked untrusted_content.
draft_send
ChatGPTSend a previously saved draft. The draft is removed from the Drafts folder after sending. Irreversible. The draft must have at least one address in to, cc or bcc: a draft with none is refused and left untouched. Pass to, cc or bcc here to set them at send time; each one given replaces the draft's stored list, and the draft keeps its body and attachments. draft_id is the most recent one (from draft_create, the latest draft_update, or draft_list): on IMAP-backed inboxes the id changes on every update, and a stale id fails with a not-found error.
draft_update
ChatGPTChange an existing draft. Each supplied field overwrites the stored one; an omitted field, body included, keeps its stored value. Pass at least one of to, cc, bcc, subject, body or attachments. Omit body to change a subject or recipients without overwriting text the user edited; draft_read returns the current text. The signature is embedded only when body is passed. attachments ADDS files; the draft's existing attachments are kept. Without body, on IMAP and Gmail a draft with inline images or other extra parts is refused and left unchanged. draft_list returns draft_id values. On IMAP-backed inboxes (anything other than Gmail/Outlook) the underlying message is rewritten, so this call returns a NEW draft_id that REPLACES the one passed in: further draft_update/draft_send calls take the returned draft_id, and the previous id no longer exists. Gmail and Outlook keep a stable draft_id across updates. The subject it returns may be one derived from a message somebody else sent (anything created by draft_reply), so the result is marked untrusted_content.
email_archive
ChatGPTMove a message out of the Inbox to the archive location. The message is kept in the archive; nothing is deleted. On Gmail this removes the INBOX label.
email_attachment
ChatGPTDownload a single attachment from an email. The bytes are always returned base64-encoded as data in structuredContent, alongside the metadata (filename, mime_type, size_bytes, attachment_index). Images and audio additionally come back in the MCP-native image/audio content block, and text/* files additionally as an embedded resource with decoded text, so clients can preview them directly; for every other type data is the file. Select the attachment by attachment_index (0-based, matching the order in email_read's attachments list) or by filename. When the message has exactly one attachment both may be omitted. It fetches one file where email_read with include_attachments fetches them all. A single attachment may be up to 25 MB; larger files are reported with their size but no data.
email_copy
ChatGPTCopy an email message into another folder, leaving the original in place. Unlike move, the source message is not removed. Available wherever inbox_list reports capabilities.copy true: every IMAP inbox (including a Gmail address connected over IMAP) and Outlook. The one connector without it is the Gmail API, whose label model has no copy operation.
email_copy_batch
ChatGPTCopy up to 500 email messages into a destination folder in one call, leaving the originals in place. Available wherever inbox_list reports capabilities.copy true: every IMAP inbox (including a Gmail address connected over IMAP) and Outlook, but not the Gmail API connector. Returns succeeded/failed counts and per-message results.
email_delete
ChatGPTDelete (trash or permanently expunge) a single email message. By default the message is moved to the provider's Trash folder (safer). Set permanent:true to hard-delete (bypasses Trash). This action may be irreversible when permanent:true is set.
email_delete_batch
ChatGPTDelete up to 500 email messages in one call. By default moves messages to Trash (safer). Set permanent:true for hard delete (bypasses Trash; irreversible). Returns succeeded/failed counts and per-message results.
email_flag
ChatGPTMark one or more messages read or unread, or add or remove a star/follow-up flag, in a single call. Set flag_action to 'read' or 'unread' to change read status, or to 'flag'/'unflag' to add or remove the flag. Pass one message ID to update a single message, or up to 500 to update many at once. Message ids come from email_list or email_search.
email_forward
ChatGPTForward an existing email to one or more new recipients. The original is relayed byte for byte: its HTML, inline images, attachments and MIME structure arrive exactly as they were sent, under an optional introductory note and the standard '---------- Forwarded message ----------' header block (From, Date, Subject, To). Originals up to 25 MB. The forward subject is prefixed with 'Fwd:' if not already present. Pass message_ids instead of message_id to forward up to 50 messages to the same recipients in one call: they go one at a time, and the result names each one's outcome, so a failure part way through never hides which ones were sent. Irreversible. The subject it reports back is derived from the original sender's own subject line, so the result is marked untrusted_content: true.
email_list
ChatGPTList email messages inside an inbox. Returns message summaries (sender, subject, date, preview, read status, attachment flag) ordered newest first. Supports filtering by folder, unread status, and pagination. It has no date filter and reads one folder: since, before and include_folders are email_search's, which needs no other criterion with them. A response is one page, not the complete result set: has_more: true means another page follows at next_offset with every other argument unchanged; only has_more: false is the end. email_read returns a message's full content. It lists the messages in one inbox; called with no inbox_id (or via inbox_list) the response lists every inbox and its inbox_id.
email_move
ChatGPTMove an email message to a different folder (or label, for Gmail). On Gmail, moving adds the destination label and removes the INBOX label; it does not remove other labels.
email_move_batch
ChatGPTMove up to 500 email messages to a destination folder in one call. On Gmail, moving adds the destination label and removes the INBOX label. Returns succeeded/failed counts and per-message results.
email_original
ChatGPTDownload one email as a complete .eml file (message/rfc822). This returns the complete MIME representation currently stored by the provider, including headers, body structure, inline content, and attachments. The .eml is returned base64-encoded as data in structuredContent, with sha256 over the same bytes so a caller can verify what it decoded; it is a saveable file, not rendered or sanitized message text. Read-only and does not mark the message as read. One message may be up to 25 MB.
email_read
ChatGPTFetch the full content of a single email by its provider message ID. Returns headers (from, to, cc, bcc, subject, date), decoded plain-text body, and optionally the sanitized HTML body and attachment data. HTML is sanitized server-side — all scripts, event handlers, and external resource references are stripped before the content is returned.
email_read_batch
ChatGPTRead multiple emails in a single call by their provider message IDs — ideal for triaging an inbox without one email_read round-trip per message. Returns a messages array (each in the same shape as email_read) plus a per-ID errors array; a single bad or missing ID never fails the whole batch. When include_attachments is true, attachment data shares a single 10 MB budget across the whole call — attachments beyond the budget are omitted. Max 50 IDs.
email_reply
ChatGPTReply to an existing email, maintaining correct thread headers (In-Reply-To, References). The recipient (Reply-To if the original has one, otherwise From), subject (prefixed with 'Re:'), and threading headers are derived from the original message — only the reply body is required. Optionally reply to all recipients of the original message using reply_all. Irreversible. The subject and recipients it reports back are derived from the original sender's headers, so the result is marked untrusted_content: true.
email_search
ChatGPTSearch an inbox using structured, provider-agnostic fields. Supply any of from, to, cc, subject, body, text, unread, has_attachment, flagged, since, before (combined with AND; on Outlook any from/to/cc/subject/body/text drops the unread, has_attachment, flagged and date filters, and the result says so); the server translates them into the inbox's native search syntax, so you never need to know provider query syntax. An optional query field is a raw provider-native escape hatch. Returns message summaries ordered by relevance or date depending on the provider. A response is one page, not the complete result set: has_more: true means another page follows at next_offset with the identical search/filter arguments; only has_more: false is the end.
email_search_and_delete
ChatGPTRun a search and delete all matching messages in one server-side operation — avoids stale message IDs. Search uses structured, provider-agnostic fields (from, to, cc, subject, body, text, unread, has_attachment, flagged, since, before) that the server translates into the inbox's native search syntax, so you never need provider query syntax; query is a raw escape hatch. Capped at 500 results per call. Default: move matches to Trash (safer). Set permanent:true for hard delete (bypasses Trash; irreversible). Returns succeeded/failed counts and per-message results.
email_search_and_move
ChatGPTMove every message matching a search into a destination folder, in one server-side operation, so no message ID is ever stale by the time it is used. Search uses structured, provider-agnostic fields (from, to, cc, subject, body, text, unread, has_attachment, flagged, since, before) that the server translates into the inbox's native search syntax, so you never need provider query syntax; query is a raw escape hatch. SEPARATE from email_move and email_move_batch, and flagged destructive to your MCP client, because it acts on everything the filter matches rather than on ids you chose: one wrong filter relocates a whole inbox. email_move and email_move_batch are for messages already listed by id. Bounded by limit, maximum and default 500: has_more: true means matches were left behind, and email_move_batch takes the remainder. On Gmail, moving adds the destination label and removes the INBOX label. Returns succeeded/failed counts and per-message results. Needs manage:folders.
email_send
ChatGPTCompose and send a new email from a connected inbox. Supports plain-text and HTML bodies, CC/BCC recipients, file attachments (max 10 MB total, either base64-encoded or referenced by source_message_id from a message already in this inbox), and a custom Reply-To address. Recipient addresses are validated against RFC 5322 before the message is sent. Irreversible.
folder_create
ChatGPTCreate a new folder (or label, for Gmail) in an inbox. Returns the provider-native folder/label ID and display name of the created item.
folder_delete
ChatGPTPermanently delete a folder (or label, for Gmail). Irreversible: depending on the provider, the messages inside are lost with it. folder_id comes from folder_list.
folder_list
ChatGPTList all folders (or labels, for Gmail) for an inbox. Returns each folder's provider-native ID, display name, type ('folder' for hierarchical providers, 'label' for Gmail), and message counts (total and unread). The returned names and ids are the 'folder' argument of email_list and the source/destination of email_move. Folder and label names are free-form text chosen by whoever created them, which on a shared, delegated or migrated mailbox is not the account owner: the result is marked untrusted_content: true.
folder_rename
ChatGPTRename an existing folder or label. folder_id comes from folder_list.
inbox_list
ChatGPTList every inbox (mailbox or account) this API key may use. It returns the inbox_id the other tools take. Each entry carries the UUID, email address, display name, provider (the connector: gmail/outlook/fastmail/imap), optional service brand (the account behind an IMAP connection: gmail/fastmail/icloud/yahoo/zoho/yandex/generic) and a capabilities object. A Gmail account connected with an app password has provider 'imap' and service 'gmail', so service, not provider, is a mailbox's brand.
reminder_cancel
ChatGPTCancel a reminder. A follow-up stops being tracked; a snoozed message is moved back to the inbox now (needs manage:folders too). id from reminder_list.
reminder_done
ChatGPTMark a reminder done: it stops being checked and leaves the due list. A snoozed message stays in its folder (reminder_cancel brings it back). id from reminder_list.
reminder_follow_up
ChatGPTTrack a message you sent and list it as due when nobody has replied by a time: message_id of the sent message (a send result's, or one from the Sent folder) and exactly one of days or due_at. The server checks for a reply about every 20 minutes, no model involved: an inbox message answering this one, not from you. A reply marks it replied; otherwise it shows as due in reminder_list until marked done or cancelled. Nothing is sent. A message is tracked once; a repeat returns the same reminder.
reminder_list
ChatGPTList the follow-ups and snoozes the server tracks. show 'due' (default): follow-ups past due with no reply, and failures; 'upcoming': pending, soonest first; 'all': everything, finished included. Subjects and addresses come from mail: the result is marked untrusted_content: true. reminder_done and reminder_cancel take an id from here.
reminder_snooze
ChatGPTMove a message out of the inbox now; the server moves it back within about a minute of until, no model involved. It waits in folder, or in "MCPEmails Snoozed" (created when missing; a label on Gmail). With condition 'no_reply' it comes back only if no reply arrived; otherwise it stays there, marked replied. reminder_cancel brings it back now.
schedule_cancel
ChatGPTCancel a pending scheduled email send. Sets the status to 'cancelled' so the dispatcher will not send the message. Only messages with status 'pending' can be cancelled — messages already in 'sending', 'sent', or 'error' state cannot be cancelled. id is the one returned by schedule_create or schedule_list.
schedule_create
ChatGPTSchedule an email to be sent at a future date and time. The message is stored in a pending queue and dispatched automatically by the server when send_at is reached. All recipient addresses and the message body are validated immediately at schedule time — if validation fails the message will not be queued. schedule_list shows pending sends and schedule_cancel stops one before it is sent.
schedule_list
ChatGPTList pending scheduled email sends for the workspace. Returns all messages with status 'pending' or 'sending', ordered by scheduled send time (earliest first). Optionally filter by inbox. The returned id is what schedule_cancel takes to stop a pending send before dispatch.
signature_get
ChatGPTRead the email signature configured for an inbox. Returns the signature HTML and plain text, whether it is enabled, the reply/forward mode ('always' | 'first_only' | 'never'), its source ('manual', 'gmail_import', or null when none is set), and sender_name, the display name recipients see in the From header (null when unset). The signature is appended server-side on send/reply/forward/draft/scheduled messages.
signature_set
ChatGPTSet or update the email signature for an inbox. Provide the signature as signature_text (plain text) and/or signature_html (rich HTML) — pass either or both; the missing half is derived automatically on send. Pass an empty string for both to clear the signature. Optionally set signature_enabled (default true; set false to stop appending without deleting the text) and signature_reply_mode ('always' = sign every reply/forward, 'first_only' = only the first message in a thread, 'never' = never sign replies/forwards). Setting a signature marks its source as 'manual', which permanently overrides Gmail auto-import for that inbox. sender_name sets the display name recipients see in the From header, e.g. "Acme Support <support@acme.example>"; it can be set on its own without touching the signature.