how to use claude computer use to send email

Claude is smart enough to write a perfect cold email, schedule a follow-up sequence, and draft a reply to your most annoying vendor. What it can't do is hit Send. Not on its own.

This trips people up. You ask Claude to email someone, and it either generates a mailto: link, writes the text to a file, or politely explains that it doesn't have access to your inbox. The gap between "Claude can write emails" and "Claude can send emails" is a plumbing problem, not an intelligence problem. And there are several ways to fix it.

How to send email with Claude: 4 methods#

1. MCP server for Gmail or Outlook connects Claude Desktop to your existing inbox via OAuth.
2. Resend or Mailtrap MCP server gives Claude Code an API-backed sending path with deliverability tracking.
3. Zapier or Make automation triggers email sends from Claude through a webhook, no MCP required.
4. Agent-native email API like LobsterMail, where the agent provisions its own inbox and sends directly through an SDK.

Each approach has real tradeoffs in setup complexity, deliverability, and how much human oversight you want. Let's walk through them.

MCP servers: the most common path#

MCP (Model Context Protocol) is Anthropic's standard for giving Claude access to external tools. An MCP server is a small process that runs alongside Claude Desktop or Claude Code and exposes capabilities like "send an email" or "search my inbox" as tool calls.

The Gmail MCP server is the most popular option. You set up OAuth credentials through Google Cloud Console, configure the server in your claude_desktop_config.json, and Claude gains read/write access to your Gmail account. Here's what the config looks like:

{
  "mcpServers": {
    "gmail": {
      "command": "npx",
      "args": ["-y", "@anthropic/gmail-mcp-server"],
      "env": {
        "GMAIL_CLIENT_ID": "your-client-id",
        "GMAIL_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}
Once connected, you can say "email Sarah the meeting notes from yesterday" and Claude will compose the message, show you a preview, and send it through your Gmail account after you confirm.

Outlook works the same way with Microsoft Graph API credentials. The setup is slightly more involved because Azure app registrations require more configuration steps than Google's developer console, but the end result is identical.

Where MCP email servers fall short#

They work well for personal productivity. Harper Reed wrote a great post about using Claude Code with MCP to triage his inbox every morning. He reviews the drafts, edits the ones that need a human touch, and sends them. For a single person managing their own email, this is genuinely useful.

The problems start when you're building something bigger:

You're sharing your credentials. The MCP server authenticates as you. Every email Claude sends comes from your personal account, with your reputation, your sending limits, and your spam score on the line. If Claude sends something weird, it's your domain that takes the hit.

Rate limits are tight. Gmail's API allows 100 messages per day for consumer accounts. Google Workspace gives you more, but you're still bound by quotas designed for humans, not automated systems.

No multi-agent support. If you have three agents that each need to send email (one for customer support, one for outreach, one for internal notifications), they'd all be fighting over the same OAuth token and the same inbox. There's no isolation between them.

Deliverability is a black box. You get no bounce tracking, no delivery confirmation, no open rates. The email leaves Gmail and you hope for the best.

For personal use, these limitations are fine. For anything production-grade, they become blockers.

Resend and Mailtrap: API-first MCP servers#

Resend and Mailtrap both offer MCP servers that connect Claude Code to a proper email sending API. Instead of piggybacking on your personal inbox, these services give you dedicated sending infrastructure with deliverability monitoring, bounce handling, and analytics.

Resend's Claude Code integration exposes 56+ tools, including template management and domain verification. You configure it as an MCP server:

{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "@resend/mcp-server"],
      "env": {
        "RESEND_API_KEY": "re_your_api_key"
      }
    }
  }
}

This is a step up from Gmail MCP for developers who need reliable delivery and tracking. You get SPF/DKIM authentication, dedicated sending domains, and proper error handling.

The catch: you still need to sign up for the service, get an API key, configure DNS records for your domain, and manage the integration yourself. For a human developer, that's an afternoon of work. For an AI agent acting autonomously, it's a series of steps that require human intervention at every gate.

Zapier: the no-code path#

If you don't want to touch MCP servers at all, Zapier offers Claude integration through webhooks. You create a Zap that triggers on a webhook, processes the payload, and sends an email through Gmail, Outlook, SendGrid, or any of Zapier's 6,000+ integrations.

Claude can fire the webhook with a tool call or through a simple HTTP request if you're using Claude Code. The advantage is flexibility. The disadvantage is latency (every email routes through Zapier's infrastructure) and the fact that you're adding another service to maintain.

For quick prototypes and personal automations, Zapier works. For production systems where you need sub-second response times or high volume, it's a bottleneck.

What about Claude computer use?#

Claude's computer use feature lets the model control your mouse and keyboard to interact with desktop applications. In theory, Claude could open your email client, click Compose, type a message, and click Send.

In practice, this is the least reliable way to send email. Computer use is designed for complex UI interactions where no API exists. Email has perfectly good APIs. Using computer use to send email is like hiring a robot arm to push buttons on a vending machine when you could just use the coin slot.

It's also slow. Each step (open app, click compose, find the To field, type the address, tab to subject, type the subject, click the body, type the message, click send) requires a screenshot, model inference, and a mouse action. A single email might take 30-60 seconds. An API call takes milliseconds.

The only scenario where computer use makes sense for email is when you're dealing with a legacy system that has no API and no MCP server. An internal corporate webmail portal from 2009 with no SMTP access, for example. Even then, I'd look for an API workaround first.

The agent-native approach#

All four methods above share an assumption: a human sets up the email infrastructure, and the agent borrows it. The human creates the Gmail account, registers the OAuth app, configures the DNS records, or signs up for the API service.

There's a fifth option that flips this. What if the agent provisions its own inbox?

LobsterMail is built for this. Your agent calls the SDK, gets a working email address with proper authentication records already configured, and starts sending. No OAuth dance. No DNS setup. No human signup.

import { LobsterMail } from "lobstermail";

const lm = new LobsterMail();
const inbox = await lm.createInbox();

await inbox.send({
  to: ["recipient@example.com"],
  subject: "Hello from my agent",
  body: { text: "Sent without a human touching a single config file." },
});

The inbox comes with SPF, DKIM, and DMARC already configured. Deliverability is handled. Each agent gets its own isolated inbox, so there's no credential sharing and no rate limit collisions between agents.

The free tier gives you 1,000 emails per month with no credit card required. The Builder tier at $9/month bumps that to 5,000 emails per month with up to 10 inboxes and custom domain support.

If you want to skip the MCP configuration entirely and let your agent handle its own email, grab an inbox here. Paste the instructions to your agent and it does the rest.

Choosing the right approach#

Your choice depends on what you're building.

If you're one person using Claude Desktop to manage your personal inbox, the Gmail MCP server is the right call. It's free, it works with your existing account, and the setup takes 15 minutes.

If you're a developer building an agent that needs to send email reliably in production, the API-backed options (Resend, Mailtrap, or LobsterMail) are worth the small investment. You get deliverability tracking, proper authentication, and the infrastructure to handle volume.

If your agent needs to self-provision without human setup steps, agent-native infrastructure is the only option that works. The agent can't fill out OAuth consent screens or add DNS records on your behalf (well, it could with computer use, but please don't).

The pattern I keep seeing: people start with Gmail MCP for prototyping, hit rate limits or deliverability issues within a week, then migrate to something purpose-built. Save yourself the migration by thinking about your production needs early.