The official CLI for Resend.

Built for humans, AI agents, and CI/CD pipelines.

██████╗ ███████╗███████╗███████╗███╗   ██╗██████╗
██╔══██╗██╔════╝██╔════╝██╔════╝████╗  ██║██╔══██╗
██████╔╝█████╗  ███████╗█████╗  ██╔██╗ ██║██║  ██║
██╔══██╗██╔══╝  ╚════██║██╔══╝  ██║╚██╗██║██║  ██║
██║  ██║███████╗███████║███████╗██║ ╚████║██████╔╝
╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝╚═╝  ╚═══╝╚═════╝

curl -fsSL https://resend.com/install.sh | bash

npm install -g resend-cli

brew install resend/cli/resend

irm https://resend.com/install.ps1 | iex

Or download the .exe directly from the GitHub releases page.

# Authenticate
resend login

# Send an email
resend emails send \
  --from "you@example.com" \
  --to delivered@resend.dev \
  --subject "Hello from Resend CLI" \
  --text "Sent from my terminal."

# Check your environment
resend doctor

This CLI ships with an agent skill that teaches AI coding agents (Cursor, Claude Code, Windsurf, etc.) how to use the Resend CLI effectively, including non-interactive flags, output formats, and common pitfalls.

To install skills for Resend's full platform (API, CLI, React Email, email best practices) from the central skills repository:

npx skills add resend/resend-skills

Use this when you want to change the CLI and run your build locally.

• Node.js 20+

1. Clone the repo

   git clone https://github.com/resend/resend-cli.git
   cd resend-cli

2. Install dependencies

   pnpm install

3. Build locally

   pnpm build

   Output: ./dist/cli.cjs

Use the dev script:

pnpm dev --version

Or run the built JS bundle:

node dist/cli.cjs --version

After editing source files, rebuild:

pnpm build

To build a standalone native binary:

pnpm build:bin

Output: ./dist/resend

The CLI resolves your API key using the following priority chain:

If no key is found from any source, the CLI errors with code auth_error.

Authenticate by storing your API key locally. The key is validated against the Resend API before being saved.

resend login

When run in a terminal, the command checks for an existing key:

• No key found: Offers to open the Resend API keys dashboard in your browser so you can create one, then prompts for the key.
• Existing key found: Shows the key source (env, config) and prompts for a new key to replace it.

Enter the key via a masked password input. Your key must start with re_.

When stdin is not a TTY, the --key flag is required:

resend login --key re_xxxxxxxxxxxxx

Omitting --key in non-interactive mode exits with error code missing_key.

On success, credentials are saved to ~/.config/resend/credentials.json with 0600 permissions (owner read/write only). The config directory is created with 0700 permissions.

# JSON output
resend login --key re_xxx --json
# => {"success":true,"config_path":"/Users/you/.config/resend/credentials.json"}

If you work across multiple Resend teams or accounts, the CLI handles that, too.

Switch between profiles without logging in and out:

resend auth switch

You can also use the global --profile (or -p) flag on any command to run it with a specific profile.

resend domains list --profile production

Send an email via the Resend API.

Provide all options via flags for scripting, or let the CLI prompt interactively for missing fields.

resend emails send \
  --from "Name <sender@example.com>" \
  --to delivered@resend.dev \
  --subject "Subject line" \
  --text "Plain text body"

When run in a terminal without all required flags, the CLI prompts for missing fields:

# prompts for from, to, subject, and body
resend emails send

# prompts only for missing fields
resend emails send --from "you@example.com"

When piped or run in CI, all required flags must be provided. Missing flags cause an error listing what's needed:

echo "" | resend emails send --from "you@example.com"
# Error: Missing required flags: --to, --subject

A body (--text, --html, or --html-file) is also required — omitting all three exits with code missing_body.

Multiple recipients:

resend emails send \
  --from "you@example.com" \
  --to delivered@resend.dev bounced@resend.dev \
  --subject "Team update" \
  --text "Hello everyone"

HTML from a file:

resend emails send \
  --from "you@example.com" \
  --to delivered@resend.dev \
  --subject "Newsletter" \
  --html-file ./newsletter.html

With CC, BCC, and reply-to:

resend emails send \
  --from "you@example.com" \
  --to delivered@resend.dev \
  --subject "Meeting notes" \
  --text "See attached." \
  --cc manager@example.com \
  --bcc delivered+1@resend.dev \
  --reply-to noreply@example.com

Overriding the API key for one send:

resend --api-key re_other_key emails send \
  --from "you@example.com" \
  --to delivered@resend.dev \
  --subject "Test" \
  --text "Using a different key"

Returns the email ID on success:

{ "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" }

Run environment diagnostics. Verifies your CLI version, API key, domains, and detects AI agent integrations.

resend doctor

The API key is always masked in output (e.g. re_...xxxx).

In a terminal, shows animated spinners for each check with colored status icons:

  Resend Doctor

  ✔ CLI Version: v0.1.0 (latest)
  ✔ API Key: re_...xxxx (source: env)
  ✔ Domains: 2 verified, 0 pending
  ✔ AI Agents: Detected: Cursor, Claude Desktop

resend doctor --json

{
  "ok": true,
  "checks": [
    { "name": "CLI Version", "status": "pass", "message": "v0.1.0 (latest)" },
    {
      "name": "API Key",
      "status": "pass",
      "message": "re_...xxxx (source: env)"
    },
    { "name": "Domains", "status": "pass", "message": "2 verified, 0 pending" },
    { "name": "AI Agents", "status": "pass", "message": "Detected: Cursor" }
  ]
}

Each check has a status of pass, warn, or fail. The top-level ok is false if any check is fail.

Exits 0 when all checks pass or warn. Exits 1 if any check fails.

With the Resend CLI, you can manage webhook endpoints so your app receives real-time event notifications.

Payloads are signed with Svix headers (svix-id, svix-timestamp, svix-signature). Verify them in your app with the Resend SDK.

For example: resend.webhooks.verify({ payload, headers, webhookSecret })

There are many events that you can listen for in your application.

For example, you can:

• Set up a POST endpoint to unsubscribe users when an email bounces or they mark your email as spam.
• Notify yourself when you get a new subscriber using the contact.created event.
• Use an email.received webhook to set up an inbox for your agent and notify it when a new email is received.

Use all with --events to subscribe to every event.

• list
• create
• get
• update
• delete
• listen

• webhooks ls → list
• webhooks rm → delete

Lists existing webhooks.

Running resend webhooks with no subcommand runs list.

Only one of --after or --before may be used. The API response includes has_more when more pages exist.

resend webhooks list
resend webhooks list --limit 25
resend webhooks list --after wh_abc123 --json

Registers a new endpoint.

The endpoint must use HTTPS. The signing_secret in the response is shown once. Store it immediately to verify incoming payloads.

In interactive mode, the CLI can prompt for endpoint and events. In non-interactive mode (pipes, CI, --json), --endpoint and --events are required.

resend webhooks create --endpoint https://app.example.com/hooks/resend --events all
resend webhooks create --endpoint https://app.example.com/hooks/resend --events email.sent email.bounced
resend webhooks create --endpoint https://app.example.com/hooks/resend --events email.sent,email.delivered

Fetches one webhook by ID.

Omit the ID in a terminal to pick from a list.

resend webhooks get wh_abc123
resend webhooks get wh_abc123 --json

The signing secret is not returned from get. To rotate secrets, delete the webhook and create a new one.

Updates the webhook:

• endpoint URL
• the full event list
• delivery status

At least one of --endpoint, --events, or --status is required.

Disabled status pauses delivery without deleting the webhook.

resend webhooks update wh_abc123 --status disabled
resend webhooks update wh_abc123 --endpoint https://new-app.example.com/hooks/resend
resend webhooks update wh_abc123 --events email.sent email.bounced

Deletes a webhook and stops deliveries.

In non-interactive mode, --yes is required to confirm.

resend webhooks delete wh_abc123 --yes

To pause delivery temporarily, prefer resend webhooks update <id> --status disabled.

Built-in local development helper. It:

• Starts a small HTTP server
• Registers a temporary Resend webhook pointing at your public tunnel URL
• Prints events in the terminal
• Deletes the webhook on exit

Your tunnel must forward to the same port as --port, e.g. ngrok http 4318.

# Terminal 1: tunnel to the listen port
ngrok http 4318

# Terminal 2: use the HTTPS URL ngrok gives you
resend webhooks listen --url https://xxxx.ngrok-free.app
resend webhooks listen --url https://xxxx.ngrok-free.app --forward-to localhost:3000/api/webhooks/resend
resend webhooks listen --url https://xxxx.ngrok-free.app --port 8080 --events email.sent email.bounced

These flags work on every command and are passed before the subcommand:

resend [global options] <command> [command options]

The CLI has two output modes:

Switching is automatic — pipe to another command and JSON output activates:

resend doctor | jq '.checks[].name'
resend emails send --from ... --to ... --subject ... --text ... | jq '.id'

Errors always exit with code 1. The format on stderr depends on output mode (same rules as the table above):

• Machine (piped stdout, CI, --json, or -q): structured JSON so stdout stays success-only for scripting (jq, etc.):

{ "error": { "message": "No API key found", "code": "auth_error" } }

• Interactive (TTY without --json / -q): a human-readable line such as Error: No API key found (still on stderr).

Set RESEND_API_KEY as an environment variable — no resend login needed:

# GitHub Actions
env:
  RESEND_API_KEY: ${{ secrets.RESEND_API_KEY }}
steps:
  - run: |
      resend emails send \
        --from "deploy@example.com" \
        --to "delivered@resend.dev" \
        --subject "Deploy complete" \
        --text "Version ${{ github.sha }} deployed."

Agents calling the CLI as a subprocess automatically get JSON output (non-TTY detection). The contract:

• Input: All required flags must be provided (no interactive prompts)
• Output: Success JSON on stdout; error JSON on stderr (use 2> or combined capture if you need both)
• Exit code: 0 success, 1 error
• Errors: Always include message and code fields
• Discovery: resend commands prints the full command tree as JSON (subcommands, options, descriptions).

Prints the CLI command tree as JSON for scripting and AI agents. In an interactive terminal, pass global --json if you need machine output; when stdout is piped, JSON is used automatically.

--dry-run is only implemented where agents most often need to validate a complex payload before a high-impact send:

• resend emails send ... --dry-run — validates inputs and prints { "dryRun": true, "request": { ... } } without sending. Attachments appear as filename and byteLength only.
• resend broadcasts create ... --dry-run — same for the broadcast create payload.

Other write commands (batch, broadcasts send, webhooks, contacts, etc.) do not support --dry-run yet. If that would help your workflow, open an issue — likely next candidates are emails batch (large JSON files) and broadcasts send (confirm id + schedule before delivery).

MIT